From 0e708f2b63c869faf69a85c14058cb1f69b196cf Mon Sep 17 00:00:00 2001 From: Claude Date: Fri, 23 Oct 2026 16:00:06 +0200 Subject: [PATCH] Document the Modern engine plan for 0.3 in docs/new_engine Modern starts as a fork of the Classic season core under src/modern/ and shares formats, GameState (with a world layout) and the match core; Classic stays unchanged. Covers the fixed Classic sizes to resolve, phases M0-M7 with acceptance criteria, the training camp catalogue with a bounded six-star tier, and the session interface the Modern UI builds against. Co-Authored-By: Claude Opus 5.5 --- docs/ENGINE_SPLIT.md | 4 ++ docs/new_engine/AGENTS.md | 11 +++++ docs/new_engine/README.md | 62 ++++++++++++++++++++++++++ docs/new_engine/befund.md | 49 +++++++++++++++++++++ docs/new_engine/phasen.md | 66 ++++++++++++++++++++++++++++ docs/new_engine/trainingslager.md | 66 ++++++++++++++++++++++++++++ docs/new_engine/ui-schnittstelle.md | 67 +++++++++++++++++++++++++++++ docs/new_ui/README.md | 4 ++ 8 files changed, 329 insertions(+) create mode 100644 docs/new_engine/AGENTS.md create mode 100644 docs/new_engine/README.md create mode 100644 docs/new_engine/befund.md create mode 100644 docs/new_engine/phasen.md create mode 100644 docs/new_engine/trainingslager.md create mode 100644 docs/new_engine/ui-schnittstelle.md diff --git a/docs/ENGINE_SPLIT.md b/docs/ENGINE_SPLIT.md index 78e3d1f..1b47949 100644 --- a/docs/ENGINE_SPLIT.md +++ b/docs/ENGINE_SPLIT.md @@ -137,6 +137,8 @@ Classic Extended is the **Classic season engine plus backported Modern features* ## 5. Modern +> **Decision for 0.3 (October 2026):** Modern starts as a **fork of the Classic season core** in `src/modern/`, sharing formats, `GameState` (with a world layout) and the match core with Classic. It runs only on Modern data sets and moves away from Classic step by step; Classic stays unchanged. The typed engine described below remains the direction, reached gradually rather than by a rewrite. The 0.3 plan, status and UI interface are documented in German under [new_engine](new_engine/README.md). + Modern is a new season engine on the typed OBW model (`docs/formats/OBW.md`): - **Data set:** an OBW world that goes beyond the original structure, for example foreign leagues with more than 12 teams, more leagues (up to 32) and real-world competition formats. It can start from an imported Classic world and be extended, or be a world of its own. @@ -174,6 +176,8 @@ Each step keeps the game playable and the Classic regression (`tools/regression/ Steps 1 to 4 are the actual split and the risky part; they are pure refactoring and must be done in small commits with the regression after each. Classic improvements continue in parallel on `bmh_season_classic`. +For 0.3 the order changes: the Modern fork (phases M0–M7 in [new_engine](new_engine/phasen.md)) comes first and shares the match core as it is; steps 1 to 4 follow later and then serve both season cores. + ## 8. Tests - **Match contract tests:** a fixed `MatchdaySetup` with fixed seeds yields a fixed `MatchdayResult` (golden files with synthetic teams, public). diff --git a/docs/new_engine/AGENTS.md b/docs/new_engine/AGENTS.md new file mode 100644 index 0000000..202dfde --- /dev/null +++ b/docs/new_engine/AGENTS.md @@ -0,0 +1,11 @@ +# Modern-Engine · Regeln für Agenten + +- Modern-Engine-Arbeit findet auf dem Branch `0.3` statt; Dokumentation liegt in `docs/new_engine/`. +- Code der Modern-Saisonlogik gehört ausschließlich nach `src/modern/` (Namespace `bmh::modern`). +- **Classic bleibt unverändert.** Gemeinsame Teile (`src/formats`, `src/game/state.*`, Zufall, Match-Kern) dürfen nur so geändert werden, dass Classic mit seinem Layout bit-identisch bleibt. Nach jeder solchen Änderung laufen Classic-Tests und Regression. +- Die Modern-Engine lädt nur Modern-Datensätze (`runtime:modern-v1`); Classic lädt keine Modern-Datensätze. +- UI-Code (RmlUi) liest Spielzustand nur über die Modern-Session und ihre Projektionen ([UI-Schnittstelle](ui-schnittstelle.md)), nie direkt aus `GameState`. +- Regeländerungen gegenüber Classic werden in [DIFFERENCES](../DIFFERENCES.md) als Modern-Abweichung festgehalten. +- Mit jeder Phase den Status in [README](README.md) und die Details in [Phasen](phasen.md) nachführen. +- Private Datensätze, echte Namen, Wappen und Fotos gehören nicht in dieses Repository; Tests nutzen synthetische Welten. +- Diese Notizen sind deutsch; Code, Kommentare und Commits englisch. diff --git a/docs/new_engine/README.md b/docs/new_engine/README.md new file mode 100644 index 0000000..c7c6709 --- /dev/null +++ b/docs/new_engine/README.md @@ -0,0 +1,62 @@ +# Modern-Engine · Plan und Stand für 0.3 + +Stand: 23. Oktober 2026. Dieses Verzeichnis beschreibt, wie die Modern-Engine +entsteht, was bereits umgesetzt ist und wo die neue Oberfläche ansetzen kann. +Grundlage ist der [Engine-Split](../ENGINE_SPLIT.md); die Oberfläche ist in +[new_ui](../new_ui/README.md) beschrieben. + +| Dokument | Inhalt | +|---|---| +| [UI-Schnittstelle](ui-schnittstelle.md) | **Einstieg für die UI:** was die Modern-Session liefert und ab wann | +| [Phasen](phasen.md) | Arbeitsschritte M0–M7 mit Abnahmekriterien | +| [Befund](befund.md) | Feste Classic-Größen im Code, die Modern auflösen muss | +| [Trainingslager](trainingslager.md) | Katalog, Preis, Wirkung und die neue 6-Sterne-Stufe | +| [Agentenregeln](AGENTS.md) | Arbeitsregeln für diesen Bereich | + +## Ziel + +Modern ist **BMH im Kern**, aber auf einem eigenen, wachsenden Datensatz: +anfangs dieselben Regeln wie Classic, mit der Zeit neue Ligen und später +angepasste Wettbewerbe (etwa eine Gruppenphase im Landesmeister-Wettbewerb). +Bahnbrechende neue Spielsysteme sind nicht geplant. Die Modern-Engine lädt +**nur Modern-Datensätze**; jede Erweiterung von Engine und Datensatz geschieht +gemeinsam. + +Der erste Modern-Datensatz (privat, Datenrevision 1.3) bringt gegenüber Classic: + +- hochauflösende Wappen und Spielerporträts (Darstellung: UI), +- Groß- und Kleinschreibung sowie getrennte Vor- und Nachnamen, +- vier internationale Ligen mit 20, 20, 20 und 18 statt je 12 Vereinen, +- 20 Spieler pro internationalem Verein wie bei den deutschen Vereinen (insgesamt 3414 Spieler, 449 Teams, davon 168 Ligavereine), +- 18 Trainingslager in drei Regionen mit Qualitätswerten bis 6 Sterne. + +Für 0.3 gilt außerdem: + +- Der menschliche Manager übernimmt nur deutsche Vereine; die internationalen Ligen laufen voll simuliert mit. +- Internationale Wettbewerbe bleiben vorerst wie in Classic, auch wenn sie veraltet sind. +- Balance-Anpassungen an Spielerdaten und Wirtschaft sind ausdrücklich erlaubt und werden dokumentiert. + +## Architektur-Entscheidung + +**Modern ist ein eigener Saison-Kern, abgezweigt von Classic; Match-Kern und Formate bleiben gemeinsam.** + +- **Classic bleibt unverändert** und bit-identisch zu seiner Regression. +- **Gemeinsam:** `src/formats`, `src/game/state.*` (mit einem `WorldLayout`, Standard = Classic), Zufallsgeneratoren und der Match-Kern (`match_engine`, `match`, `reality_*`, `rating`, `lineup`). +- **Abgezweigt nach `src/modern/`:** die Saisonlogik (Tagesablauf, Woche, Monat, Saison, Pokale, Spieltagsvorbereitung, Schreibtischaktionen, Karriere, Nationalteams, Transfers, Spielpläne) und eine eigene `ModernSession`. Nur dort werden feste Größen durch das Layout ersetzt und neue Regeln eingeführt. +- Damit kann sich Modern Schritt für Schritt von Classic entfernen, ohne Classic zu gefährden. Fehler im gemeinsamen Match-Kern wirken auf beide; Fehler in der Saisonlogik werden bei Bedarf in beide Kerne übernommen. +- Der typisierte Match-Vertrag aus dem Engine-Split bleibt das langfristige Ziel, ist aber keine Voraussetzung für 0.3. + +## Phasen und Status + +| Phase | Inhalt | Status | +|---|---|---| +| M0 | Classic-Referenz festhalten, Datensatz lokal bereitstellen | offen | +| M1 | `WorldLayout`, Abzweig `src/modern/`, vereinsbezogene Blöcke typisiert | offen | +| M2 | Spielpläne je Liga (Round-Robin), Kalender mit 38 Spieltagen | offen | +| M3 | Modern-Weltlader, Namen (Vor-/Nachname, UTF-8), Asset-Schlüssel | offen | +| M4 | Trainingslager: 18 Lager, drei Regionen, 6-Sterne-Wirkung | offen | +| M5 | Datenrevision 1.4 des Modern-Datensatzes (privat), Wirtschaftsprüfung | offen | +| M6 | Modern-Spielstände (`modern-career-v1`), Projektionen für die UI | offen | +| M7 | Balance-Läufe und Anpassungen | offen | + +Details und Abnahmekriterien stehen in [Phasen](phasen.md). diff --git a/docs/new_engine/befund.md b/docs/new_engine/befund.md new file mode 100644 index 0000000..5c75a72 --- /dev/null +++ b/docs/new_engine/befund.md @@ -0,0 +1,49 @@ +# Befund · Feste Classic-Größen im Code + +Stand: 23. Oktober 2026, Branch `0.3`. Diese Liste zeigt, warum größere +internationale Ligen und Kader kein reiner Konstantentausch sind. Zeilenangaben +können sich verschieben; maßgeblich sind die genannten Funktionen. + +## Kaderplätze + +- `src/game/state.cpp` (`kBigSquadTeams = 90`, `kTeamsWithSquads = 168`, `squad_range`): Teams 0–89 haben 24 Kaderplätze, Teams 90–137 (Auslandsligen) 16 Plätze ab `team * 16 + 720`; alle anderen keine. +- Hinter den Kadern (Platz 2928 = 90 × 24 + 48 × 16) folgen Pools: Transferliste (44 Plätze), vereinslose Spieler (80), Auslandsangebote (20), Bereich ohne Verein ab 3072, insgesamt 3150 Plätze. +- Diese Grenzen stehen als Zahlen in `month.cpp`, `weekly.cpp`, `poach.cpp`, `national.cpp`, `club_player_detail.cpp`, `career.cpp`, `matchday_setup.cpp`, `season.cpp`, `import/obw.cpp` und vielfach in `app/career_session.cpp`. +- Auslandskader sind auf 15 Spieler begrenzt (Käufersuche in `weekly.cpp`), der Mindestkader liegt bei 14 (`poach.cpp`). + +## Vereins-IDs + +- 0–137 Ligavereine (90 deutsch, 48 international), 138–167 Amateure, 168–356 Pokal-Ausländer (27 Nationen × 7), 357 = `kNoTeam` (`state.hpp`), insgesamt 419. +- Abgeleitete Prüfungen: `season.cpp` (Amateur-Pool, Gesamtzahl), `match.cpp` (Pokal-Ausländer in Siebenerblöcken), `rating.cpp` und `other_games.cpp` (`team - 168`), `match_engine.cpp`, Wappenprüfungen in `app/controller.cpp`, `app/main.cpp`, `app/career_session.cpp`. +- 30 zusätzliche Ligavereine überschneiden sich mit dem Bereich der Pokal-Ausländer und mit `kNoTeam`. + +## Ligen, Spielpläne, Kalender + +- `set_league_sizes` (`schedule.cpp`) verlangt in Summe genau 138 Ligavereine. +- Alle Auslandsligen nutzen die Spielplantabelle von Liga 5; eine Liga mit 18 neben Ligen mit 20 Vereinen würde falsche Teams paaren. +- `set_fixture_tables` kennt nur Tabellen für 4, 6, 12, 16, 18 und 20 Vereine. +- Die Auslandsligen teilen sich ein Kalenderbit; der Classic-Kalender hat dort Termine für 22 Runden, nicht für 38. +- Unkritisch: `kResultsSize` reicht für 9 Ligen mit 20 Vereinen, Tabellen fassen 20 Einträge. + +## Speicherabbild und Spielstand + +- Mehrere Blöcke sind pro Verein fest dimensioniert (`formats/savestate.cpp`, `game/memory.hpp`): Spielhistorie der Manager (5 × 168 × 10), Kurznamen-Offsets (168), Trikotwahl (419), Stärke der Pokal-Ausländer (251), Saisondaten der Vereine (168 × 74 Byte), Ranghistorie (138 × 26), Zusatzbytes (168). +- Blöcke liegen an festen Adressen hintereinander und können nicht wachsen. +- `game/save.cpp` und `game/career.cpp` verwenden die Standardzählung (2574 Spieler, 419 Vereine). +- Importer und Classic-Spielstände prüfen genau 419 Vereine, 2574 Spieler und 168 Kader. + +## Unkritisch + +- Spieler-IDs sind in Kaderplätzen und Angeboten 12 Bit breit (bis 4094), Vereins-IDs in Leihen 10 Bit (bis 1023). +- Typisierte Vektoren (`players`, `squad_slots`, `team_morale`, `club_table` usw.) können wachsen. +- Namenspools nutzen 16-Bit-Offsets (64 KB); Modern führt Namen deshalb getrennt als UTF-8. + +## Laden + +- Pakete mit `editor:world-v1` werden heute bewusst abgewiesen (`content/package.cpp`, `import/obw.cpp`). Ein typisiertes Weltmodell gibt es nicht; der Editor arbeitet JSON-basiert (`src/editor/world.*`, `ArchiveStore`). + +## Wirtschaft + +- Computer-Vereine besitzen kein Geld; Buchungen (`book_money`) betreffen nur menschliche Manager. +- Startfinanzen entstehen beim Zuweisen eines Managers aus Spielstufe und Startliga (`career.cpp`). Neue Vereine, die kein Mensch übernimmt, brauchen deshalb keine Startfinanzen. +- Marktwert und Gehalt folgen aus Technik, Kondition, Alter, Position und Erfahrung (`market_value` in `month.cpp`). diff --git a/docs/new_engine/phasen.md b/docs/new_engine/phasen.md new file mode 100644 index 0000000..0cb9e0b --- /dev/null +++ b/docs/new_engine/phasen.md @@ -0,0 +1,66 @@ +# Phasen · Modern-Engine 0.3 + +Jede Phase hält das Spiel lauffähig. **Classic-Prüfung nach jeder Phase:** +`ctest -C Release -E repo_hygiene` und die Classic-Regression identisch zur +Referenz aus M0. + +## M0 · Grundlage + +- Classic-Referenz festhalten: Regressionsausgaben, Langläufe, Tag auf `0.3`. +- Modern-Datensatz lokal bereitstellen (privat, nicht in dieses Repository). + +**Abnahme:** Referenzen liegen vor; spätere Phasen vergleichen dagegen. + +## M1 · `WorldLayout` und Abzweig + +- `WorldLayout` in `src/game/state.hpp`: Ligagrößen, ID-Bereiche (Liga, Amateure, Pokal-Ausländer, Nationalteams, `kNoTeam`), Kaderplätze pro Team, Pool-Offsets, Gesamtzahl der Plätze, Spieler- und Vereinsanzahl. `classic_layout()` liefert die heutigen Werte; `squad_range` liest das Layout. +- Gemeinsame Teile lesen Teambereiche aus dem Layout (`match_engine`, `rating`, `match`). +- Saisonlogik nach `src/modern/game/` kopieren (Bibliothek `bmh_season_modern`, Namespace `bmh::modern`); dort alle festen Größen aus dem [Befund](befund.md) durch Layoutwerte ersetzen. +- Vereinsbezogene Speicherblöcke werden in Modern zu Vektoren, die nach der Vereinsanzahl bemessen sind; Classic behält seine Blöcke. + +**Abnahme:** Classic identisch; Modern-Kern baut und läuft mit Classic-Layout identisch zu Classic (Gegenprobe, dass der Abzweig nichts verändert hat). + +## M2 · Ligen, Spielpläne, Kalender + +- Spielplangenerator je Liga aus den Daten: `round-robin` (Kreismethode, jede Größe, Heim/Auswärts ausgeglichen) für die internationalen Ligen, `legacy:` für die deutschen Ligen aus den Classic-Tabellen des Datensatzes. +- Kalender: Der Tagesplan der Saison wird beim Start aus dem Classic-Plan erzeugt und für die internationalen Ligen auf 38 Runden ergänzt. Ligen mit weniger Runden setzen danach aus. Tabellen, Prognose und Saisonende rechnen je Liga mit `2 × (Vereine − 1)` Spieltagen. +- Europapokal-Teilnehmer aus den internationalen Ligen werden wie bisher bestimmt, mit den neuen Teambereichen. + +**Abnahme:** Synthetische Welt mit Ligen von 20, 20, 20 und 18 Vereinen spielt eine Saison vollständig durch; jede Paarung genau einmal pro Hin- und Rückrunde. + +## M3 · Modern-Weltlader + +- Ein Paket ist Modern, wenn `requires` `runtime:modern-v1` enthält; der Mod-Ordner darf zusätzlich `mod.json` mit `type: modern` tragen (Ansatz aus dem Modern-POC). +- Ablauf (`src/modern/content/world_loader.*`): Archiv lesen → Classic-Startzustand aus den Classic-Datenbereichen des Pakets aufbauen → Welttabellen darüberlegen (Vereine, Ligen, Kader und Reihenfolge, Spielerwerte `bmh-classic@1`, Verträge) → `WorldLayout` aus den Daten ableiten. +- Namen: `GameState` erhält UTF-8-Felder für Vor- und Nachname sowie Vereinsname und Kurzname. Texte der Engine (Post, Meldungen, Ranglisten, Konsole) verwenden in Modern einen gemeinsamen Namenszugriff. +- Asset-Schlüssel (Wappen, Porträts, Trophäen) werden unverändert an die UI weitergegeben. +- Gegenseitiger Ausschluss: Modern lehnt Classic-Pakete ab und umgekehrt. + +**Abnahme:** Der Modern-Datensatz startet eine Karriere mit einem deutschen Verein; Kader, Namen und Ligen stimmen mit den Welttabellen überein. + +## M4 · Trainingslager + +Siehe [Trainingslager](trainingslager.md): Katalog aus den Daten, drei Regionen, Qualitätswerte 0–6, unveränderte Preisformel und Aufenthaltsgrenzen, begrenzte 6-Sterne-Wirkung. + +**Abnahme:** Tests für Preis, Grenzen und Wirkung mit festen Seeds; Simulation: drei Aufenthalte in 6-Sterne-Lagern bringen einem Spitzenteam im Schnitt höchstens etwa einen Tabellenplatz. + +## M5 · Datenrevision 1.4 (privat) + +- Neue, nummerierte Migration des Modern-Datensatzes nach dem bestehenden Migrationsvertrag (Eingangs-Hash, Bericht, unabhängige Prüfung, Editor-Roundtrip): `runtime:modern-v1`, spielbar, Trainingslager-Katalog, Kalenderangaben für 38 Spieltage, Finanzangaben auch für die 30 neuen Vereine. +- Werkzeug: C++ (`openbmh_world_migrate`) oder das bestehende Migrationswerkzeug der Datenpflege; vor Beginn abstimmen. + +**Abnahme:** Prüfbericht ohne Fehler; Editor öffnet und speichert verlustfrei. + +## M6 · Spielstände und UI-Projektionen + +- Spielstände `.obs` mit `save_profile: modern-career-v1`: gleiche Hülle wie Classic, aber Modern-Zustand mit Layout und Namen; Dimensionen aus der Welt. +- Projektionen und Aktionen der `ModernSession` gemäß [UI-Schnittstelle](ui-schnittstelle.md). + +**Abnahme:** Speichern und Laden mitten in der Saison setzt identisch fort; UI-Projektionen haben Tests mit synthetischen Welten. + +## M7 · Balance + +- Konsolen-Langläufe mit dem Modern-Datensatz (mehrere Startkonstellationen, je zehn Saisons): Tore pro Spiel, Punkteverteilung je Liga, Ermüdung und Verletzungen bei 38 statt 22 Spieltagen, Marktwerte und Gehälter, Finanzen des menschlichen Vereins, Wirkung der Trainingslager. +- Korrekturen zuerst in den Daten (etwa Werte der neu ergänzten Spieler, Preise), dann in Regeln; jede Regeländerung in [DIFFERENCES](../DIFFERENCES.md). + +**Abnahme:** Bericht mit Kennzahlen und begründeten Anpassungen. diff --git a/docs/new_engine/trainingslager.md b/docs/new_engine/trainingslager.md new file mode 100644 index 0000000..d0ea018 --- /dev/null +++ b/docs/new_engine/trainingslager.md @@ -0,0 +1,66 @@ +# Trainingslager · Modern-Engine + +Stand: 23. Oktober 2026, Planung für Phase M4. Angebot und Bedienung der +Oberfläche stehen in [new_ui/desktop/trainingcamp](../new_ui/desktop/trainingcamp/README.md). + +## Classic heute (Ausgangspunkt) + +Quelle: `src/game/desk_actions.cpp` (`training_camp_price`, `book_training_camp`, `training_camp_effect`). + +- Acht Lager mit Basispreis und vier Qualitätswerten von 1 bis 5. +- **Preis:** Basispreis + 5000 × Anzahl der Kaderspieler. Eine Buchung ist ein Aufenthalt; es gibt keine Dauer oder Wochenpreise. +- **Grenzen:** höchstens ein Aufenthalt pro Woche und drei pro Saison; die Buchung scheitert, wenn Guthaben plus Kreditrahmen nicht reichen. +- **Schwerpunkte:** drei Regler von 0 bis 15; der vierte Wert (Erholung) folgt aus `15 − (a + b + c) / 3`. +- **Wirkung** mit `scaled(x, note) = x × note × 20 / 100`: + - Mannschaftsmoral: `+ scaled(12, Verpflegung)`, höchstens 47. + - Je Spieler und Wert (Kondition, Technik, Form, Eingespieltheit, Frische) eine Zufallsstufe aus der Tabelle `{−3 … +5}`; der Zufallsbereich reicht bis Index `scaled(Schwerpunkt, Note) + 8`. Ein höherer Schwerpunkt mal Note verschiebt die Verteilung zu größeren Schritten. + - Platzqualität wirkt auf Technik und Form, Fitness auf Kondition, Verpflegung auf Moral, Unterkunft auf Eingespieltheit und Frische. + - Trainingsobergrenze je Wert: Zufall 83–87; die beiden teuersten Classic-Lager (Index ab 6) heben sie um 1. + - Ältere Spieler trainieren seltener (Chance sinkt ab 14 Jahren Rohalter in Zehnerschritten). + +## Modern: Katalog aus den Daten + +Der Katalog steht im Modern-Datensatz unter `rules.training_camps`. Fehlt er, +gilt die öffentliche Vorgabe `assets/modern/rules/training_camps.json` mit den +18 fiktiven Lagern der Oberfläche. + +```json +{ + "id": "camp:04", + "region": "eu", + "name": {"default": "Sportzentrum Groningen"}, + "place": {"default": "Groningen"}, + "country": "nation:nl", + "position": {"lat_e6": 53219400, "lon_e6": 6566500}, + "quality": {"pitch": 4, "fitness": 4, "catering": 4, "lodging": 4}, + "base_price": 485000, + "image": "asset:camp/04/image" +} +``` + +- `region`: `de` (Deutschland), `eu` (übriges Europa), `me` (Naher Osten). +- `position`: Breite und Länge in Millionstel Grad als Ganzzahlen, weil der JSON-Leser der Laufzeit keine Gleitkommazahlen kennt. +- `quality`: je 0–6; die Reihenfolge in der UI ist Platz, Fitness, Verpflegung, Unterkunft. +- Die numerischen IDs 0–17 der Oberfläche bleiben als `camp:00` bis `camp:17` erhalten und werden nicht neu sortiert. +- Preis, Grenzen und Schwerpunkte bleiben wie in Classic. + +## Die 6-Sterne-Stufe + +Ziel: spürbar besser als 5 Sterne, aber nicht übermächtig. Die Lager des Nahen +Ostens kosten 2,8–3,6 Mio. € gegenüber höchstens 0,92 Mio. € in Europa. + +1. **Normale Skalierung, gedeckelt:** Die Note 6 geht wie jede andere in `scaled()` ein. Der Zufallsindex wird auf das Tabellenende begrenzt, sodass kein Einzelschritt größer als +5 wird. Bei vollem Schwerpunkt gleicht das 5 Sternen; bei mittlerem Schwerpunkt fällt die Verteilung etwas günstiger aus. Moral steigt um 14 statt 12. +2. **Höheres Leistungsdach:** Das bisherige Premium-Merkmal „Index ab 6“ wird zu „Platzqualität mindestens 5“ (+1 auf die Trainingsobergrenze). Haben Platz und Fitness beide 6 Sterne, kommt ein weiterer Punkt hinzu (+2 insgesamt). Spitzenspieler können damit etwas höher trainiert werden, aber nicht über 99. +3. **Regeneration:** Bei 6 Sternen Unterkunft verkürzt sich die Restdauer jeder laufenden Verletzung im Kader einmalig um eine Woche (nicht unter eine Woche). Bei 6 Sternen Verpflegung erhält jeder Spieler zusätzlich bis zu +1 Kondition (höchstens bis zur Obergrenze). + +Prüfung in M4 und M7: Ein Spitzenteam, das pro Saison dreimal ein +6-Sterne-Lager bucht, verbessert sich gegenüber drei 5-Sterne-Aufenthalten im +Schnitt höchstens um etwa einen Tabellenplatz. Andernfalls werden die Punkte 2 +und 3 abgeschwächt. Das Ergebnis wird hier und in [DIFFERENCES](../DIFFERENCES.md) festgehalten. + +## Für die Oberfläche + +Die Modern-Session liefert Katalog, Buchungsstand (Aufenthalte dieser Saison, +Buchung diese Woche), aktuelle Schwerpunkte und den Preis für den eigenen Kader. +Aktionen: Schwerpunkte setzen, Lager buchen. Einzelheiten in der +[UI-Schnittstelle](ui-schnittstelle.md#trainingslager). diff --git a/docs/new_engine/ui-schnittstelle.md b/docs/new_engine/ui-schnittstelle.md new file mode 100644 index 0000000..17e78e3 --- /dev/null +++ b/docs/new_engine/ui-schnittstelle.md @@ -0,0 +1,67 @@ +# UI-Schnittstelle · Modern-Engine + +Stand: 23. Oktober 2026. **Einstieg für die Arbeit an der Modern UI.** Hier steht, +was die Modern-Engine der Oberfläche liefert, ab welcher Phase es verfügbar ist +und womit die UI bis dahin arbeitet. + +## Grundsatz + +- Die Modern UI (RmlUi) spricht ausschließlich mit der **`ModernSession`** (`src/modern/app/modern_session.hpp`, ab M1) und deren Projektionen. Sie liest nie direkt `GameState` und rechnet keine Spielregeln nach (Preise, Grenzen, Tabellen). +- Projektionen sind unveränderliche Momentaufnahmen mit einer **Revision**. Aktionen geben die neue Revision oder einen Fehlercode mit deutscher und englischer Meldung zurück; abgelehnte Aktionen ändern nichts. +- Identitäten sind die stabilen OBW-IDs (`club:…`, `player:…`, `comp:…`, `camp:…`), nicht Laufzeitindizes. +- Bilder werden über Asset-Schlüssel referenziert (`asset:club//crest`, `asset:player//photo`, `asset:comp//trophy`, `asset:camp//image`). Auflösung und Rückfallbilder (Silhouette, generisches Wappen) übernimmt die UI über das Asset-Verzeichnis des Datensatzes. +- Texte aus der Engine (Post, Meldungen) kommen als fertige UTF-8-Zeichenketten in der gewählten Sprache. + +## Verzeichnisaufteilung + +| Pfad | Inhalt | Zuständig | +|---|---|---| +| `src/modern/game/` | Saisonlogik (Abzweig von Classic) | Engine | +| `src/modern/content/` | Laden der Modern-Welt, Spielstände | Engine | +| `src/modern/app/` | `ModernSession`, Projektionen, Aktionen | Engine | +| `src/modern/ui/` | RmlUi-Fenster, Ansichten, Modell der Oberfläche | UI | + +Der bestehende POC (`modern::Model` mit `Snapshot`, Branch `assist/codex-0.2-modern-poc`) kann weitergeführt werden. Er hängt künftig an der `ModernSession` statt an der Classic-`CareerSession`. Wird der POC übernommen, wandert er nach `src/modern/ui/`. + +## Projektionen und Aktionen + +| Bereich | Projektion | Aktionen | Ab Phase | +|---|---|---|---| +| Sitzung | `SessionInfo`: Datensatz-Titel, Datenrevision, Sprache, Währung | Neue Karriere, Laden, Speichern | M3 (Laden/Speichern M6) | +| Karrierestart | `ClubChoice[]`: nur deutsche Vereine in 0.3, mit Liga, Name, Kurzname, Wappen | Manager anlegen, Verein wählen | M3 | +| Statusleiste | `DeskStatus`: Verein, Manager, Termin bzw. Saisonvorbereitung, Saison, Guthaben | – | M3 | +| Ligen | `LeagueInfo[]`: ID, Name, Land, Stufe, Anzahl Vereine (12–20), Spieltage | – | M2 | +| Tabelle | `LeagueTable`: bis 20 Zeilen mit Verein, Spiele, S/U/N, Tore, Punkte, Platzierung | – | M2 | +| Spielplan | `Fixtures`: je Liga und Spieltag die Paarungen und Ergebnisse | – | M2 | +| Kader | `Squad`: bis 24 Plätze; je Spieler ID, Vorname, Nachname, Position, Alter, Werte, Vertrag, Porträt | Aufstellung tauschen | M3 | +| Spieler | `PlayerCard`: Detailwerte, Marktwert, Gehalt, Statistik | – | M3 | +| Trainingslager | siehe unten | Schwerpunkte setzen, buchen | M4 | +| Post | `Mail[]`: Datum, Absender, Betreff, Text | Gelesen markieren | M3 | +| Spieltag | Fortschritt und Ereignisse über den bestehenden Match-Kern | Weiter, Eingriffe | M3 | + +Alles, was hier noch fehlt (Transfers, Finanzen, Stadion, Umfeld und weitere +Menüs), folgt nach demselben Muster. Jedes neue Menü der UI bekommt in diesem +Dokument eine Zeile, sobald seine Projektion festgelegt ist. + +## Trainingslager + +Projektion `TrainingCampView`: + +- `camps[]`: ID, Region (`de`, `eu`, `me`), Name, Ort, Land, Position, vier Qualitätswerte (0–6), Basispreis, Bildschlüssel, +- `price`: Preis für den aktuellen Kader (Basispreis + 5000 × Spieler) je Lager, +- `stays_this_season` (0–3), `booked_this_week`, `affordable` je Lager, +- `focus`: Kondition, Technik, Spiel (0–15) und die abgeleitete Erholung. + +Aktionen: + +- `set_camp_focus(kondition, technik, spiel)`: Fehler, wenn ein Wert außerhalb 0–15 liegt. +- `book_camp(camp_id)`: Fehler `camp_week_used`, `camp_season_limit`, `camp_unaffordable` oder `camp_unknown`; bei Erfolg bucht die Engine den Preis, wendet die Wirkung an und liefert die neue Revision. + +Die bisherige POC-Vormerkung bleibt ein reiner UI-Zustand; erst `book_camp` +löst eine Buchung aus. Regeln und 6-Sterne-Wirkung: [Trainingslager](trainingslager.md). + +## Bis die Engine liefert + +- Die UI arbeitet mit dem POC-Zustand oder mit Beispieldaten in genau den oben genannten Formen. Beispieldaten sind fiktiv und liegen bei den UI-Tests, nicht im Datensatz. +- Weicht eine Projektion von dieser Beschreibung ab, wird zuerst dieses Dokument angepasst, dann der Code. +- Fragen zur Schnittstelle als GitHub-Issue mit dem Label `modern-engine`. diff --git a/docs/new_ui/README.md b/docs/new_ui/README.md index d70dd72..cd46087 100644 --- a/docs/new_ui/README.md +++ b/docs/new_ui/README.md @@ -14,3 +14,7 @@ Implementierung in der Spiel-Engine. Jeder Bereich nennt die geprüfte Quelle, bestehende Funktionen und offene Entscheidungen für die Engine-Anbindung. Die Architekturgrundlage bleibt der [Engine-Split](../ENGINE_SPLIT.md). + +Was die Modern-Engine der Oberfläche liefert und ab welcher Phase, steht in der +[UI-Schnittstelle der Modern-Engine](../new_engine/ui-schnittstelle.md); Plan +und Stand der Engine in [new_engine](../new_engine/README.md).