diff --git a/docs/architecture.md b/docs/architecture.md index cec2bde..2fd0208 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -1,10 +1,10 @@ # Rinkplanner – Architektur & Entscheidungen (Phase 1) -Stand: 2026-10-30 +Stand: 2026-10-31 Grundlage: `rinkplanner/rinkplanner_definition_agent_guidelines.md` Übergeordnete Reihenfolge: `docs/roadmap.md` -Letzte Session: `docs/findings-2026-10-30-element-marker.md` -(Session davor: `docs/findings-2026-10-30.md`) +Letzte Session: `docs/findings-2026-10-31-isu-katalog.md` +(Session davor: `docs/findings-2026-10-30-element-marker.md`) ## 1. Leitentscheidung @@ -26,8 +26,8 @@ wird nicht weiterentwickelt. Phase 2 konsumiert später dasselbe Datenmodell ├── project.godot ├── src/ │ ├── core/model/ # reine Daten-Resources - │ └── core/rules/ # ISU-Regeln (folgt) - ├── whiteboard/ # Phase 1: view / ctrl / io (folgt) + │ ├── core/rules/ # ISU-Katalog (JSON + Lookup) + │ └── whiteboard/ # Phase 1: view / ctrl / io ├── scenes/ # dünne Szenen, die Views zusammensetzen ├── assets/ ├── tests/ # headless GDScript-Tests @@ -56,6 +56,13 @@ Implementiert in `rinkplanner/src/core/model/`: | `PathSegment` | durchgehender Pfad mit Richtung, Kante, Dauer, Element-Marker und Label | | `RinkDimensions` | Maße, Koordinaten, Punkte-/Kurvenprüfung | +Implementiert in `rinkplanner/src/core/rules/`: + +| Klasse | Verantwortung | +| :--- | :--- | +| `ElementDefinition` | Elementfamilie (z. B. `CCoSp`) mit Typ, Name und Base Values je Level | +| `ElementCatalog` | saisonaler JSON-Katalog, Lookup nach Kürzel/Level, Vorschläge, Prüfung | + ### Entscheidungen **D1 – Segment statt Section als Träger von Richtung und Kante.** @@ -98,6 +105,18 @@ gehört in den Controller, nicht ins Modell. `validate() -> PackedStringArray` ist die primäre API; `is_valid()` ist nur eine Abkürzung. So kann die UI Fehler konkret anzeigen. +**D8 – Das ISU-Regelwerk ist saisonal externalisiert.** +Der Elementkatalog liegt als JSON unter `src/core/rules/data/` und trägt +Saison, Quelle und Gültigkeitsdatum. `ElementCatalog` liest ihn zur Laufzeit +und löst Kürzel plus Level zu Base Values auf. Segmente speichern nur +`element_code` und `element_level`, keine abgeleiteten Punkte; dadurch bleibt +eine neue SoV eine reine Datenaustausch-Aufgabe. Kürzel werden +case-insensitiv und auch als kanonischer Code mit Level-Suffix (`CCoSp4`, +`StSqB`) gefunden; ein Suffix im Kürzel hat Vorrang und wird beim Übernehmen +ins Level-Feld normalisiert. Unbekannte Kürzel oder Level liefern `-1` statt +einen stillen Standardwert. Das JSON wird über `include_filter="*.json"` in die +Exporte aufgenommen. + ## 4. View- und Controller-Grenzen - **View** (`Node2D`/`Control`) liest das Modell und zeichnet. Sie verändert @@ -139,9 +158,11 @@ eine Abkürzung. So kann die UI Fehler konkret anzeigen. Bereiche entstehen, indem ein gezeichnetes Segment über den Inspector getaggt wird. Punktmarker haben eine **Standzeit** (`element_duration_seconds`) mit Typ-Defaults (Sprung 0,7 s, Pirouette 8 s, Sequenz 0 s), die im - Inspector übersteuert wird und in die Timeline eingeht. Die Timing-Details - (Dauer/Tempo/Profil) werden beim Setzen und für Punktmarker ausgeblendet, - damit die Leiste auch im Landscape kompakt bleibt. + Inspector übersteuert wird und in die Timeline eingeht. Der Inspector zeigt + außerdem den **Base Value** des eingegebenen Kürzels und Levels aus dem + Saisonkatalog; unbekannte Kürzel werden als „nicht im Katalog“ markiert. + Die Timing-Details (Dauer/Tempo/Profil) werden beim Setzen und für + Punktmarker ausgeblendet, damit die Leiste auch im Landscape kompakt bleibt. - **Section-Verwaltung:** Ein Panel rechts zeigt die chronologische Abschnittsliste. Neue Sections werden angelegt, umbenannt, gelöscht und hoch-/runtergeschoben; `sequence_order` wird nach jeder Änderung @@ -289,12 +310,16 @@ Aktueller Stand: - **Model:** 81 Assertions für Rink-Geometrie, Clamping, Segment-Timing, Timing-Modi, Template-Metadaten, Element-Marker samt Kürzel-/Level-/Dauer-Grenzen, Schema-Version, Section-Aggregation und Routine-Validierung. +- **Regelwerk:** 160 Assertions für Katalog-Metadaten, Saison/Quelle, + Sprung-/Pirouetten-/Sequenz-Base-Values, Level-Auflösung, Kürzel-Suffixe, + Case-Insensitivität, Vorschläge, Segment-Integration und fehlerhafte Kataloge. - **Canvas:** 90 Assertions für Meter→Pixel-Mapping, Fit/Zoom/Pan, Rink-Kontur und die reine Bogen-Geometrie. -- **Whiteboard:** 201 Assertions für Controller-Verdrahtung, Segmenterzeugung, +- **Whiteboard:** 208 Assertions für Controller-Verdrahtung, Segmenterzeugung, Linien-/Bogenpfade, Klemmen an der Bande, Auswahl, Griff- und Richtungs-/Kanten-Bearbeitung, Segmentlöschung, Element-Marker (Setzen, - Typwechsel, Inspector inkl. Standzeit, Verschieben, Löschen), Section-Verwaltung, + Typwechsel, Inspector inkl. Standzeit und Base-Value-Hinweis, Verschieben, + Löschen), Section-Verwaltung, Ghosting-Zustand, Segment-Labels inklusive Dialog und Sichtbarkeits-Schalter, Speichern/Laden, Schema-Prüfung, Dirty-State, Navigationsmodus und den Maus-Drag-Pfad. diff --git a/docs/findings-2026-10-31-isu-katalog.md b/docs/findings-2026-10-31-isu-katalog.md new file mode 100644 index 0000000..56054f5 --- /dev/null +++ b/docs/findings-2026-10-31-isu-katalog.md @@ -0,0 +1,90 @@ +# Findings – Session: ISU-Elementkatalog (2026-10-31) + +Ergänzung zu `docs/findings-2026-10-30-element-marker.md`. +Diese Session hat den ersten Schritt des ISU-Regelwerks umgesetzt: einen +saisonalen Elementkatalog mit Base Values und Leveln, inklusive Anbindung an +den Element-Inspector. + +## Ergebnis + +| Ziel | Ergebnis | +| :--- | :--- | +| Katalogmodell | `ElementDefinition` + `ElementCatalog` in `src/core/rules/` | +| Daten | `isu_sov_2025_26.json`: 24 Sprünge, 16 Pirouetten, 2 Sequenzen | +| Quelle | ISU Communication No. 2707, gültig ab 2025-07-01 | +| Lookup | Familie + Level, kanonische Suffixe, case-insensitiv, `-1` bei Unbekanntem | +| UI | Base-Value-Hinweis im Element-Inspector inkl. Quellen-Tooltip | +| Tests | 766 Assertions gesamt, `./tools/test.sh` grün (neu: 160 Regelwerk) | + +## Entscheidungen + +- **Daten statt Code:** Der Katalog ist JSON mit `schema_version`, `season`, + `valid_from` und `source`. Eine neue Saison ersetzt die Datei; Modell und + Canvas bleiben unverändert. +- **Familie plus Level:** Ein Eintrag beschreibt die Familie (`CCoSp`) und + trägt die Base Values für Base–4. Sprünge sind nicht levelbar und haben + genau einen Wert. Ein Level-Suffix im eingegebenen Kürzel (`CCoSp4`) wird + beim Übernehmen abgetrennt und ins Level-Feld übernommen; gespeichert wird + die Familie. +- **Keine abgeleiteten Werte am Segment:** `PathSegment` speichert weiterhin + nur `element_code` und `element_level`. Der Base Value wird bei Bedarf + aufgelöst, damit SoV-Updates alte Kürdaten nicht verfälschen. +- **Strenge Lookups:** Unbekannte Kürzel/Level liefern `-1.0`, damit die UI + den Unterschied zwischen „0 Punkte“ und „nicht im Katalog“ zeigen kann. +- **Ein-Level-Fallback:** `ChSq` existiert nur als `ChSq1`; ein bloßes `ChSq` + löst deshalb auf dieses eine Level auf. Das ist die einzige bewusste + Ausnahme. +- **Export:** Alle Presets führen `*.json` über `include_filter` mit, weil + der Katalog per `FileAccess` und nicht als importierte Ressource geladen + wird. + +## Umfang der Daten + +- Sprünge `1T`–`4A` inklusive `3A` (im PDF mit kyrillischem `А`; beim + Erzeugen normalisiert). +- Pirouetten: `USp`, `LSp`, `CSp`, `SSp`, `FUSp`, `FLSp`, `FCSp`, `FSSp`, + `CUSp`, `FCUSp`, `CLSp`, `FCLSp`, `CoSp`, `FCoSp`, `CCoSp`, `FCCoSp`. +- Sequenzen: `StSq` (Base–4), `ChSq` (Level 1). + +Bewusst nicht enthalten: GOE-Tabellen, `V`-Varianten, `q`/`e`/`!`/`<`/`<<`- +Suffixe, Kombinationen/Folgen, Paarlauf- und Eistanz-Elemente, Features und +Level-Bestimmung. + +## Bedienung + +- Der Element-Inspector zeigt `Base Value: 3,50` unter der Level-Auswahl. +- Der Hinweis folgt Typ, Kürzel und Level; bei unbekannten Kürzeln steht + „Kürzel nicht im Katalog 2025/26“. +- Der Tooltip nennt Saison und Quelle. +- Der Hinweis `ElementHint` hat jetzt eine feste Mindestbreite (480 px). + Ohne sie berechnete das autowrap-Label seine Höhe bei Breite 1 und trieb + den Dialog auf mehrere tausend Pixel; der Dialog bleibt nun bei 520 × 506 + und zeigt seine Buttons. + +## Tests + +Neu: `tests/run_rules_tests.gd` (160 Assertions) + +- Metadaten: Saison, Quelle, Gültigkeitsdatum, 42 Familien, eindeutige Codes +- Stichproben aller Elementgruppen (u. a. `3Lz`, `3A`, `4A`, `CCoSp4`, `StSq3`, `ChSq1`) +- Level-Auflösung, Suffix-Erkennung, Case-Insensitivität, Typfilter +- Vorschläge nach Kürzel und Anzeigename +- Segment-Integration inkl. Typ-Mismatch +- Fehlerfälle: fehlende Datei, unbekannter Typ, ungültiger Level-Key, Duplikat + +Erweitert: `tests/run_whiteboard_tests.gd` (201 → 208 Assertions) prüft, dass +der Controller den Katalog lädt, Level-Suffixe normalisiert und der Inspector +`2,50`, `3,50` bzw. den „nicht im Katalog“-Hinweis zeigt. + +## Offene Punkte + +1. **Features und Level:** Der Katalog kennt Level, aber nicht die Kriterien, + die zu einem Level führen. +2. **Varianten:** GOE, `V`, Unterrotation und Fehlkante fehlen; Kürzel bleiben + dafür Freitext. +3. **Zusammengesetzte Elemente:** Sprungkombinationen und -folgen werden noch + nicht strukturiert abgebildet. +4. **Adult-Regeln:** Die Adult-Kürzelnormen (erlaubte Elemente, Wiederholungen, + Zeitlimits) sind nicht Teil des Katalogs. +5. **Vorschläge in der UI:** `suggest()` ist vorhanden, aber der Inspector + zeigt noch keine Autovervollständigung. diff --git a/docs/isu-rules.md b/docs/isu-rules.md new file mode 100644 index 0000000..70a7caa --- /dev/null +++ b/docs/isu-rules.md @@ -0,0 +1,126 @@ +# ISU-Regelwerk – Elementkatalog + +Stand: 2026-10-31 +Saison: **2025/26** +Quelle: ISU Communication No. 2707, *Single & Pair Skating – Scale of Values +valid as of July 1, 2025* (ersetzt Communication 2656) + +## Zweck + +Der Katalog liefert die Base Values (BV) zu Elementkürzeln und Leveln. Er ist +bewusst reine Daten und vom Whiteboard entkoppelt: Eine neue Saison ersetzt +eine JSON-Datei, nicht den Modell- oder Controller-Code. + +Aktuell abgedeckt: + +- **24 Sprünge** von `1T` bis `4A` +- **16 Pirouettenfamilien** der Einzel- und Paarlauf-SoV + (einpositionig, mit Fußwechsel, Kombinationen, jeweils auch geflogen) +- **2 Sequenzen**: `StSq` (Base–4) und `ChSq` (nur Level 1) + +Nicht abgedeckt (bewusst offen): GOE-Tabellen, reduzierte `V`-Varianten, +Unterrotations-/Fehlkanten-Suffixe (`<`, `<<`, `q`, `e`, `!`), Sprungkombinationen +und -folgen, Paarlauf-Hebungen/Twists/Throws, Eistanz-Elemente, Feature-Kriterien +und die daraus abgeleitete Level-Bestimmung. + +## Dateien + +| Datei | Inhalt | +| :--- | :--- | +| `rinkplanner/src/core/rules/data/isu_sov_2025_26.json` | aktiver Katalog | +| `rinkplanner/src/core/rules/element_catalog.gd` | Laden, Lookup, Vorschläge, Prüfung | +| `rinkplanner/src/core/rules/element_definition.gd` | eine Elementfamilie mit BV je Level | +| `rinkplanner/tests/run_rules_tests.gd` | Headless-Tests inkl. Stichproben | + +## Datenformat + +```json +{ + "schema_version": 1, + "season": "2025/26", + "discipline": "Single & Pair Skating", + "valid_from": "2025-07-01", + "source": "ISU Communication No. 2707, ...", + "elements": [ + { + "code": "3Lz", + "name": "Triple Lutz", + "type": "jump", + "base_value": 5.90 + }, + { + "code": "CCoSp", + "name": "Change foot combination spin", + "type": "spin", + "base_values": { + "B": 1.70, "1": 2.00, "2": 2.50, "3": 3.00, "4": 3.50 + } + } + ] +} +``` + +- `code` ist die **Familie** ohne Level-Suffix (`3Lz`, `CCoSp`, `StSq`). +- `type` ist `jump`, `spin` oder `sequence` und wird auf + `PathSegment.ElementType` abgebildet. +- Sprünge haben genau einen `base_value` (Level 0). Pirouetten und Sequenzen + nutzen `base_values` mit `"B"` für Base und `"1"`–`"4"` für die Level. +- Werte sind Dezimalzahlen mit Punkt; die UI zeigt sie mit Komma. + +## Lookup-Regeln + +`ElementCatalog` bietet: + +```gdscript +var catalog := ElementCatalog.load_default() +catalog.find("CCoSp") # ElementDefinition oder null +catalog.get_base_value("CCoSp", 4) # 3.50 +catalog.get_base_value("CCoSp4", -1) # 3.50 (Level aus Suffix) +catalog.get_base_value("3Lz", 2) # 5.90 (Sprunglevel wird ignoriert) +catalog.get_base_value("3X") # -1.0 +catalog.get_segment_base_value(segment) # BV eines getaggten Segments +catalog.suggest(PathSegment.ElementType.SPIN, "ccosp", 8) +``` + +- Lookup ist getrimmt und case-insensitiv. +- Kanonische Codes mit Suffix (`CCoSp4`, `StSqB`) werden akzeptiert; ein Suffix + im Kürzel hat Vorrang vor der Level-Auswahl. +- Der Controller trennt beim Übernehmen ein Level-Suffix vom Kürzel ab und + setzt das Level-Feld. Gespeichert wird immer die Familie, z. B. `CCoSp` + + Level 4 statt `CCoSp4` + Level 3. +- Unbekannte Kürzel, falsche Typen und nicht vorhandene Level liefern `-1.0` + statt eines stillen Defaults. +- Existiert ein Element nur auf einem Level (`ChSq1`), löst ein bloßes `ChSq` + auf dieses eine Level auf. +- Der Base Value wird **nicht** am Segment gespeichert. Das Segment trägt nur + `element_code` und `element_level`; die Anzeige fragt den Katalog. + +## Bedienung + +Der Element-Inspector zeigt unter der Level-Auswahl `Base Value: 3,50`. +Unbekannte Kürzel erscheinen als „Kürzel nicht im Katalog 2025/26“. Der +Hinweis aktualisiert sich bei Änderungen an Typ, Kürzel und Level; der Tooltip +nennt Saison und Quelle. + +## Neue Saison einpflegen + +1. Neue ISU-Communication (Scale of Values) beschaffen und als JSON nach dem + obigen Schema anlegen, z. B. `isu_sov_2026_27.json`. +2. `season`, `valid_from` und `source` aktualisieren. +3. `ElementCatalog.DEFAULT_PATH` auf die neue Datei zeigen lassen. +4. Stichproben in `tests/run_rules_tests.gd` auf die neuen Werte anpassen + (mindestens ein Sprung, eine Pirouette, eine Sequenz). +5. `./tools/test.sh` ausführen. +6. Die alte Datei kann für Nachvollziehbarkeit im Repo bleiben; aktiv ist + immer genau eine Datei. + +Die JSON-Datei wird über `include_filter="*.json"` in allen Export-Presets +mit ausgeliefert. + +## Nächste Ausbaustufen + +- Level-/Feature-Prüfung (welche Features ergeben welches Level) +- GOE-Tabellen und `V`-/Unterrotations-Varianten +- Sprungkombinationen und -folgen als zusammengesetzte Elemente +- Programmvalidierung (erlaubte Elementanzahl, Wiederholungen, Adult-Regeln) +- Vorschlagsliste im Inspector direkt aus `suggest()` diff --git a/docs/roadmap.md b/docs/roadmap.md index 7889e2b..6449a4f 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -1,6 +1,6 @@ # Rinkplanner – Roadmap -Stand: 2026-10-31 (PoC: Sync-Komfort und UI-Refactoring zurückgestellt) +Stand: 2026-10-31 (ISU-Katalog begonnen; Sync-Komfort und UI-Refactoring zurückgestellt) Diese Reihenfolge ist die verbindliche Arbeitsgrundlage für Phase 1. Änderungen nur bewusst und nach Rücksprache. Erkenntnisse der letzten Session: `docs/findings-2026-10-30-element-marker.md`. @@ -107,12 +107,19 @@ Voraussetzung für Phase 1. - [x] Tests für Marker-Modell, Interaktion und Export erweitern - [ ] Optional: Elementkatalog mit Kürzelvorschlägen (Teil des ISU-Regelwerks) -### Nächste Session: ISU-Regelwerk +### In Arbeit: ISU-Regelwerk -- [ ] Elementkatalog als strukturierte Daten (JSON/Resources) -- [ ] Base Values, Level und Features +- [x] Elementkatalog als strukturierte Daten (JSON/Resources) + – Saison 2025/26 mit 24 Sprüngen, 16 Pirouetten und 2 Sequenzen; + Format und Pflege in `docs/isu-rules.md` +- [x] Base Values und Level je Elementfamilie +- [x] Regelversionen pflegbar halten (saisonale JSON-Datei mit Quelle und + Gültigkeitsdatum) +- [x] Base-Value-Hinweis im Element-Inspector +- [ ] Features und Kriterien für die Level-Vergabe - [ ] Validierung von Elementen und Kombinationen -- [ ] Regelversionen pflegbar halten +- [ ] Optional: Kürzelvorschläge im Inspector aus `suggest()` +- [ ] Optional: GOE-Tabellen sowie `V`-/Unterrotationsvarianten ### Danach: Weitere fachliche Erweiterungen @@ -136,10 +143,11 @@ fachlichen Validierung angefasst. Übernahme des Feedbacks der Tester Die Reihenfolge ist bewusst: native Builds, Datenaustausch und Element-Marker -sind erledigt. Im PoC folgt jetzt die vollständige ISU-Logik; Sync-Komfort und -UI-Refactoring sind zurückgestellt, weil der bestehende Stand für Tests genügt -und die endgültige Sync-Architektur (PHP-Webserver) sowie das UI-Feedback der -Tester ohnehin noch ausstehen. +sind erledigt. Im PoC läuft jetzt das ISU-Regelwerk – der Katalog steht, als +Nächstes folgen Features und Validierung. Sync-Komfort und UI-Refactoring sind +zurückgestellt, weil der bestehende Stand für Tests genügt und die endgültige +Sync-Architektur (PHP-Webserver) sowie das UI-Feedback der Tester ohnehin noch +ausstehen. ## Querschnittsaufgaben diff --git a/rinkplanner/export_presets.cfg b/rinkplanner/export_presets.cfg index 8bbe85e..ac5f996 100644 --- a/rinkplanner/export_presets.cfg +++ b/rinkplanner/export_presets.cfg @@ -7,7 +7,7 @@ advanced_options=false dedicated_server=false custom_features="" export_filter="all_resources" -include_filter="" +include_filter="*.json" exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*" export_path="build/linux/rinkplanner.x86_64" patches=PackedStringArray() @@ -39,7 +39,7 @@ advanced_options=false dedicated_server=false custom_features="" export_filter="all_resources" -include_filter="" +include_filter="*.json" exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*" export_path="build/windows/rinkplanner.exe" patches=PackedStringArray() @@ -94,7 +94,7 @@ advanced_options=false dedicated_server=false custom_features="" export_filter="all_resources" -include_filter="" +include_filter="*.json" exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*" export_path="build/macos/rinkplanner.zip" patches=PackedStringArray() @@ -214,7 +214,7 @@ advanced_options=false dedicated_server=false custom_features="" export_filter="all_resources" -include_filter="" +include_filter="*.json" exclude_filter="tests/*,prototype/*,docs/*,addons/*,assets/models/*" export_path="build/android/rinkplanner.apk" patches=PackedStringArray() diff --git a/rinkplanner/scenes/whiteboard/whiteboard.tscn b/rinkplanner/scenes/whiteboard/whiteboard.tscn index 2d1f0e9..d924a70 100644 --- a/rinkplanner/scenes/whiteboard/whiteboard.tscn +++ b/rinkplanner/scenes/whiteboard/whiteboard.tscn @@ -565,7 +565,7 @@ caret_blink = true [node name="ElementDialog" type="ConfirmationDialog" parent="."] unique_name_in_owner = true title = "Element" -size = Vector2i(520, 420) +size = Vector2i(520, 460) ok_button_text = "Übernehmen" cancel_button_text = "Abbrechen" @@ -573,7 +573,7 @@ cancel_button_text = "Abbrechen" offset_left = 12.0 offset_top = 12.0 offset_right = 508.0 -offset_bottom = 350.0 +offset_bottom = 390.0 theme_override_constants/separation = 8 [node name="ElementTypeLabel" type="Label" parent="ElementDialog/ElementBox"] @@ -615,6 +615,13 @@ custom_minimum_size = Vector2(0, 56) layout_mode = 2 theme_override_font_sizes/font_size = 17 +[node name="ElementValueLabel" type="Label" parent="ElementDialog/ElementBox"] +unique_name_in_owner = true +layout_mode = 2 +theme_override_colors/font_color = Color(0.74902, 0.803922, 0.878431, 1) +theme_override_font_sizes/font_size = 15 +text = "Base Value: –" + [node name="ElementDurationLabel" type="Label" parent="ElementDialog/ElementBox"] layout_mode = 2 theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) @@ -631,6 +638,7 @@ step = 0.1 suffix = " s" [node name="ElementHint" type="Label" parent="ElementDialog/ElementBox"] +custom_minimum_size = Vector2(480, 0) layout_mode = 2 theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) theme_override_font_sizes/font_size = 14 diff --git a/rinkplanner/src/core/rules/data/isu_sov_2025_26.json b/rinkplanner/src/core/rules/data/isu_sov_2025_26.json new file mode 100644 index 0000000..b087542 --- /dev/null +++ b/rinkplanner/src/core/rules/data/isu_sov_2025_26.json @@ -0,0 +1,365 @@ +{ + "schema_version": 1, + "season": "2025/26", + "discipline": "Single & Pair Skating", + "valid_from": "2025-07-01", + "source": "ISU Communication No. 2707, Scale of Values valid as of July 1, 2025", + "elements": [ + { + "code": "1T", + "name": "Single toe loop", + "type": "jump", + "base_value": 0.4 + }, + { + "code": "1S", + "name": "Single Salchow", + "type": "jump", + "base_value": 0.4 + }, + { + "code": "1Lo", + "name": "Single loop", + "type": "jump", + "base_value": 0.5 + }, + { + "code": "1F", + "name": "Single flip", + "type": "jump", + "base_value": 0.5 + }, + { + "code": "1Lz", + "name": "Single Lutz", + "type": "jump", + "base_value": 0.6 + }, + { + "code": "1A", + "name": "Single Axel", + "type": "jump", + "base_value": 1.1 + }, + { + "code": "2T", + "name": "Double toe loop", + "type": "jump", + "base_value": 1.3 + }, + { + "code": "2S", + "name": "Double Salchow", + "type": "jump", + "base_value": 1.3 + }, + { + "code": "2Lo", + "name": "Double loop", + "type": "jump", + "base_value": 1.7 + }, + { + "code": "2F", + "name": "Double flip", + "type": "jump", + "base_value": 1.8 + }, + { + "code": "2Lz", + "name": "Double Lutz", + "type": "jump", + "base_value": 2.1 + }, + { + "code": "2A", + "name": "Double Axel", + "type": "jump", + "base_value": 3.3 + }, + { + "code": "3T", + "name": "Triple toe loop", + "type": "jump", + "base_value": 4.2 + }, + { + "code": "3S", + "name": "Triple Salchow", + "type": "jump", + "base_value": 4.3 + }, + { + "code": "3Lo", + "name": "Triple loop", + "type": "jump", + "base_value": 4.9 + }, + { + "code": "3F", + "name": "Triple flip", + "type": "jump", + "base_value": 5.3 + }, + { + "code": "3Lz", + "name": "Triple Lutz", + "type": "jump", + "base_value": 5.9 + }, + { + "code": "3A", + "name": "Triple Axel", + "type": "jump", + "base_value": 8.0 + }, + { + "code": "4T", + "name": "Quadruple toe loop", + "type": "jump", + "base_value": 9.5 + }, + { + "code": "4S", + "name": "Quadruple Salchow", + "type": "jump", + "base_value": 9.7 + }, + { + "code": "4Lo", + "name": "Quadruple loop", + "type": "jump", + "base_value": 10.5 + }, + { + "code": "4F", + "name": "Quadruple flip", + "type": "jump", + "base_value": 11.0 + }, + { + "code": "4Lz", + "name": "Quadruple Lutz", + "type": "jump", + "base_value": 11.5 + }, + { + "code": "4A", + "name": "Quadruple Axel", + "type": "jump", + "base_value": 12.5 + }, + { + "code": "USp", + "name": "Upright spin", + "type": "spin", + "base_values": { + "B": 1.0, + "1": 1.2, + "2": 1.5, + "3": 1.9, + "4": 2.4 + } + }, + { + "code": "LSp", + "name": "Layback spin", + "type": "spin", + "base_values": { + "B": 1.2, + "1": 1.5, + "2": 1.9, + "3": 2.4, + "4": 2.7 + } + }, + { + "code": "CSp", + "name": "Camel spin", + "type": "spin", + "base_values": { + "B": 1.1, + "1": 1.4, + "2": 1.8, + "3": 2.3, + "4": 2.6 + } + }, + { + "code": "SSp", + "name": "Sit spin", + "type": "spin", + "base_values": { + "B": 1.1, + "1": 1.3, + "2": 1.6, + "3": 2.1, + "4": 2.5 + } + }, + { + "code": "FUSp", + "name": "Flying upright spin", + "type": "spin", + "base_values": { + "B": 1.5, + "1": 1.7, + "2": 2.0, + "3": 2.4, + "4": 2.9 + } + }, + { + "code": "FLSp", + "name": "Flying layback spin", + "type": "spin", + "base_values": { + "B": 1.7, + "1": 2.0, + "2": 2.4, + "3": 2.9, + "4": 3.2 + } + }, + { + "code": "FCSp", + "name": "Flying camel spin", + "type": "spin", + "base_values": { + "B": 1.6, + "1": 1.9, + "2": 2.3, + "3": 2.8, + "4": 3.2 + } + }, + { + "code": "FSSp", + "name": "Flying sit spin", + "type": "spin", + "base_values": { + "B": 1.7, + "1": 2.0, + "2": 2.3, + "3": 2.6, + "4": 3.0 + } + }, + { + "code": "CUSp", + "name": "Change foot upright spin", + "type": "spin", + "base_values": { + "B": 1.5, + "1": 1.7, + "2": 2.0, + "3": 2.4, + "4": 2.9 + } + }, + { + "code": "FCUSp", + "name": "Flying change foot upright spin", + "type": "spin", + "base_values": { + "B": 1.5, + "1": 1.7, + "2": 2.0, + "3": 2.4, + "4": 2.9 + } + }, + { + "code": "CLSp", + "name": "Change foot layback spin", + "type": "spin", + "base_values": { + "B": 1.7, + "1": 2.0, + "2": 2.4, + "3": 2.9, + "4": 3.2 + } + }, + { + "code": "FCLSp", + "name": "Flying change foot layback spin", + "type": "spin", + "base_values": { + "B": 1.7, + "1": 2.0, + "2": 2.4, + "3": 2.9, + "4": 3.2 + } + }, + { + "code": "CoSp", + "name": "Combination spin", + "type": "spin", + "base_values": { + "B": 1.5, + "1": 1.7, + "2": 2.0, + "3": 2.5, + "4": 3.0 + } + }, + { + "code": "FCoSp", + "name": "Flying combination spin", + "type": "spin", + "base_values": { + "B": 1.5, + "1": 1.7, + "2": 2.0, + "3": 2.5, + "4": 3.0 + } + }, + { + "code": "CCoSp", + "name": "Change foot combination spin", + "type": "spin", + "base_values": { + "B": 1.7, + "1": 2.0, + "2": 2.5, + "3": 3.0, + "4": 3.5 + } + }, + { + "code": "FCCoSp", + "name": "Flying change foot combination spin", + "type": "spin", + "base_values": { + "B": 1.7, + "1": 2.0, + "2": 2.5, + "3": 3.0, + "4": 3.5 + } + }, + { + "code": "StSq", + "name": "Step sequence", + "type": "sequence", + "base_values": { + "B": 1.5, + "1": 1.8, + "2": 2.6, + "3": 3.3, + "4": 3.9 + } + }, + { + "code": "ChSq", + "name": "Choreographic step sequence", + "type": "sequence", + "base_values": { + "1": 3.0 + } + } + ] +} diff --git a/rinkplanner/src/core/rules/element_catalog.gd b/rinkplanner/src/core/rules/element_catalog.gd new file mode 100644 index 0000000..de52280 --- /dev/null +++ b/rinkplanner/src/core/rules/element_catalog.gd @@ -0,0 +1,304 @@ +class_name ElementCatalog +extends RefCounted + +## Season-specific ISU element catalog (Scale of Values). +## +## The catalog is pure data (JSON) plus read-only lookups. It stays independent +## of the whiteboard controller so annual SoV updates only replace the data +## file. Lookups accept family codes ("CCoSp", "StSq") and canonical codes with +## a level suffix ("CCoSp4", "StSqB"). Jump levels are ignored because jumps +## have a single base value. + +const DEFAULT_PATH := "res://src/core/rules/data/isu_sov_2025_26.json" +const SUPPORTED_SCHEMA_VERSION := 1 + +const TYPE_BY_NAME := { + "jump": PathSegment.ElementType.JUMP, + "spin": PathSegment.ElementType.SPIN, + "sequence": PathSegment.ElementType.SEQUENCE, +} + +var schema_version: int = 0 +var season: String = "" +var discipline: String = "" +var valid_from: String = "" +var source: String = "" + +var _definitions: Array[ElementDefinition] = [] +var _by_key: Dictionary[String, ElementDefinition] = {} +var _errors: PackedStringArray = PackedStringArray() + + +static func load_default() -> ElementCatalog: + return load_from(DEFAULT_PATH) + + +static func load_from(path: String) -> ElementCatalog: + var catalog := ElementCatalog.new() + catalog._parse_file(path) + return catalog + + +## All definitions in file order (jumps, spins, sequences). +func get_definitions() -> Array[ElementDefinition]: + var copy: Array[ElementDefinition] = [] + copy.assign(_definitions) + return copy + + +func get_definition_count() -> int: + return _definitions.size() + + +## Looks up a family by code. The lookup is case-insensitive and also accepts +## canonical codes with a level suffix, e.g. "CCoSp4" or "StSqB". +func find(code: String) -> ElementDefinition: + var key := _normalize(code) + if key.is_empty(): + return null + if _by_key.has(key): + return _by_key[key] + var stripped := _strip_level_suffix(key) + if stripped != key and _by_key.has(stripped): + return _by_key[stripped] + return null + + +func has_code(code: String) -> bool: + return find(code) != null + + +## Level encoded in a canonical code suffix ("CCoSp4" -> 4, "StSqB" -> 0), +## or -1 when the code has no suffix. +func get_level_suffix(code: String) -> int: + return _level_from_code(code) + + +## Returns the base value for a code and level, or -1 when the code is unknown, +## the level is missing or the code belongs to another element type. +## A level of -1 is inferred from a trailing suffix ("4", "B"). An explicit +## suffix in [param code] wins over [param level], because the canonical code is +## self-describing. +func get_base_value( + code: String, + level: int = -1, + expected_type: PathSegment.ElementType = PathSegment.ElementType.NONE +) -> float: + var definition := find(code) + if definition == null: + return -1.0 + if ( + expected_type != PathSegment.ElementType.NONE + and definition.element_type != expected_type + ): + return -1.0 + + var resolved := _level_from_code(code) + if resolved < 0: + resolved = level + if resolved < 0: + resolved = 0 + # Some elements only exist at one level (ChSq1). A bare family code then + # resolves to that single level instead of reporting it as unknown. + if not definition.has_level(resolved) and resolved == 0: + var levels := definition.get_levels() + if levels.size() == 1: + resolved = levels[0] + + return definition.get_base_value(resolved) + + +## Base value of an element-tagged segment. Sequences without a code and +## elements outside the catalog return -1. +func get_segment_base_value(segment: PathSegment) -> float: + if segment == null or not segment.is_element(): + return -1.0 + if segment.element_code.strip_edges().is_empty(): + return -1.0 + return get_base_value( + segment.element_code, + segment.element_level, + segment.element_type + ) + + +## Family codes for one element type, in file order. +func get_codes( + type: PathSegment.ElementType = PathSegment.ElementType.NONE +) -> PackedStringArray: + var codes := PackedStringArray() + for definition: ElementDefinition in _definitions: + if type != PathSegment.ElementType.NONE and definition.element_type != type: + continue + codes.append(definition.code) + return codes + + +## Family codes for the inspector, matched against code or display name. +func suggest( + type: PathSegment.ElementType, + query: String, + limit: int = 8 +) -> PackedStringArray: + var codes := PackedStringArray() + if limit <= 0: + return codes + var needle := query.strip_edges().to_lower() + for definition: ElementDefinition in _definitions: + if type != PathSegment.ElementType.NONE and definition.element_type != type: + continue + if ( + not needle.is_empty() + and not definition.code.to_lower().begins_with(needle) + and not definition.display_name.to_lower().contains(needle) + ): + continue + codes.append(definition.code) + if codes.size() >= limit: + break + return codes + + +func get_errors() -> PackedStringArray: + return _errors.duplicate() + + +func validate() -> PackedStringArray: + var errors := _errors.duplicate() + if schema_version != SUPPORTED_SCHEMA_VERSION: + errors.append( + "unsupported catalog schema %d (expected %d)" + % [schema_version, SUPPORTED_SCHEMA_VERSION] + ) + if season.strip_edges().is_empty(): + errors.append("catalog season must not be empty") + if source.strip_edges().is_empty(): + errors.append("catalog source must not be empty") + if _definitions.is_empty(): + errors.append("catalog contains no elements") + return errors + + +func is_valid() -> bool: + return validate().is_empty() + + +func _parse_file(path: String) -> void: + var file := FileAccess.open(path, FileAccess.READ) + if file == null: + _errors.append("cannot open element catalog '%s'" % path) + return + + var json := JSON.new() + var error := json.parse(file.get_as_text()) + if error != OK: + _errors.append( + "invalid catalog JSON at line %d: %s" + % [json.get_error_line(), json.get_error_message()] + ) + return + + if typeof(json.data) != TYPE_DICTIONARY: + _errors.append("catalog root must be a JSON object") + return + + _parse_root(json.data as Dictionary) + + +func _parse_root(data: Dictionary) -> void: + schema_version = int(data.get("schema_version", 0)) + season = str(data.get("season", "")).strip_edges() + discipline = str(data.get("discipline", "")).strip_edges() + valid_from = str(data.get("valid_from", "")).strip_edges() + source = str(data.get("source", "")).strip_edges() + + var entries: Variant = data.get("elements", []) + if typeof(entries) != TYPE_ARRAY: + _errors.append("catalog 'elements' must be an array") + return + + for entry: Variant in entries: + if typeof(entry) != TYPE_DICTIONARY: + _errors.append("catalog contains a non-object element entry") + continue + var definition := _parse_definition(entry as Dictionary) + if definition == null: + continue + + for message: String in definition.validate(): + _errors.append("%s: %s" % [definition.code, message]) + + var key := _normalize(definition.code) + if _by_key.has(key): + _errors.append("duplicate element code '%s'" % definition.code) + continue + _by_key[key] = definition + _definitions.append(definition) + + +func _parse_definition(entry: Dictionary) -> ElementDefinition: + var code := str(entry.get("code", "")).strip_edges() + var type_name := str(entry.get("type", "")).strip_edges().to_lower() + + if not TYPE_BY_NAME.has(type_name): + _errors.append("unknown element type '%s' for code '%s'" % [type_name, code]) + return null + + var definition := ElementDefinition.new() + definition.code = code + definition.display_name = str(entry.get("name", "")).strip_edges() + definition.element_type = TYPE_BY_NAME[type_name] + + if entry.has("base_values"): + var values: Variant = entry["base_values"] + if typeof(values) != TYPE_DICTIONARY: + _errors.append("'base_values' of '%s' must be an object" % code) + return null + for level_key: Variant in values as Dictionary: + var level := ElementDefinition.parse_level_key(str(level_key)) + if level < 0: + _errors.append( + "'%s' contains invalid level key '%s'" % [code, str(level_key)] + ) + continue + var raw: Variant = (values as Dictionary)[level_key] + if typeof(raw) != TYPE_FLOAT and typeof(raw) != TYPE_INT: + _errors.append("'%s' level '%s' must be numeric" % [code, str(level_key)]) + continue + definition.base_values[level] = float(raw) + elif entry.has("base_value"): + var raw: Variant = entry["base_value"] + if typeof(raw) != TYPE_FLOAT and typeof(raw) != TYPE_INT: + _errors.append("'%s' base_value must be numeric" % code) + return null + definition.base_values[0] = float(raw) + else: + _errors.append("'%s' has no base value" % code) + return null + + return definition + + +static func _normalize(code: String) -> String: + return code.strip_edges().to_lower() + + +static func _strip_level_suffix(key: String) -> String: + if key.length() < 2: + return key + var last := key.substr(key.length() - 1, 1) + if last == "b" or (last >= "1" and last <= "4"): + return key.substr(0, key.length() - 1) + return key + + +static func _level_from_code(code: String) -> int: + var key := _normalize(code) + if key.length() < 2: + return -1 + var last := key.substr(key.length() - 1, 1) + if last == "b": + return 0 + if last >= "1" and last <= "4": + return int(last) + return -1 diff --git a/rinkplanner/src/core/rules/element_catalog.gd.uid b/rinkplanner/src/core/rules/element_catalog.gd.uid new file mode 100644 index 0000000..c3e2325 --- /dev/null +++ b/rinkplanner/src/core/rules/element_catalog.gd.uid @@ -0,0 +1 @@ +uid://c1ejwcb07c75f diff --git a/rinkplanner/src/core/rules/element_definition.gd b/rinkplanner/src/core/rules/element_definition.gd new file mode 100644 index 0000000..4e98484 --- /dev/null +++ b/rinkplanner/src/core/rules/element_definition.gd @@ -0,0 +1,109 @@ +class_name ElementDefinition +extends Resource + +## One element family from the ISU Scale of Values. +## +## A family combines the base code with its difficulty levels, e.g. "CCoSp" +## with Base and levels 1-4. Jumps are not levelled: they keep a single base +## value at level 0. Values come from a season-specific catalog file so annual +## SoV updates never touch the model or the canvas. + +const MAX_LEVEL := PathSegment.ELEMENT_MAX_LEVEL + +@export var code: String = "" +@export var display_name: String = "" +@export var element_type: PathSegment.ElementType = PathSegment.ElementType.NONE +## Base value per level. Key 0 is "Base", keys 1-4 are the graded levels. +@export var base_values: Dictionary[int, float] = {} + + +func is_leveled() -> bool: + return element_type != PathSegment.ElementType.JUMP + + +func has_level(level: int) -> bool: + return base_values.has(level) + + +## Returns the base value for [param level], or -1 when the level is unknown. +## Jumps ignore the level and always use their single value. +func get_base_value(level: int) -> float: + var resolved := level + if not is_leveled(): + resolved = 0 + if not base_values.has(resolved): + return -1.0 + return base_values[resolved] + + +## Levels present in this definition, ascending. Empty for invalid data. +func get_levels() -> Array[int]: + var levels: Array[int] = [] + levels.assign(base_values.keys()) + levels.sort() + return levels + + +## Canonical code for a level, e.g. "CCoSpB", "CCoSp4" or "3Lz". +func get_code_for_level(level: int) -> String: + if not is_leveled(): + return code + return code + level_key(level) + + +## All canonical codes of this family. +func get_codes() -> PackedStringArray: + var codes := PackedStringArray() + for level: int in get_levels(): + codes.append(get_code_for_level(level)) + return codes + + +static func level_key(level: int) -> String: + return "B" if level <= 0 else str(level) + + +## Parses "B" (base) or "0"-"4" and returns -1 for anything else. +static func parse_level_key(key: String) -> int: + var cleaned := key.strip_edges().to_upper() + if cleaned == "B": + return 0 + if cleaned.is_valid_int(): + var level := int(cleaned) + if level >= 0 and level <= MAX_LEVEL: + return level + return -1 + + +static func level_label(level: int) -> String: + return "Base" if level <= 0 else "Level %d" % level + + +func validate() -> PackedStringArray: + var errors := PackedStringArray() + + if code.strip_edges().is_empty(): + errors.append("code must not be empty") + if display_name.strip_edges().is_empty(): + errors.append("display_name must not be empty") + if element_type == PathSegment.ElementType.NONE: + errors.append("element_type must not be NONE") + if base_values.is_empty(): + errors.append("base_values must not be empty") + return errors + + for level: int in base_values: + if level < 0 or level > MAX_LEVEL: + errors.append("base_values contains invalid level %d" % level) + if base_values[level] <= 0.0: + errors.append("base value at level %d must be positive" % level) + + if not is_leveled(): + if base_values.size() != 1 or not base_values.has(0): + errors.append("jumps must carry exactly one base value at level 0") + + return errors + + +func is_valid() -> bool: + return validate().is_empty() diff --git a/rinkplanner/src/core/rules/element_definition.gd.uid b/rinkplanner/src/core/rules/element_definition.gd.uid new file mode 100644 index 0000000..d547c1d --- /dev/null +++ b/rinkplanner/src/core/rules/element_definition.gd.uid @@ -0,0 +1 @@ +uid://bhsdd8u4bcgby diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index 7d75870..2fc3e14 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -49,6 +49,7 @@ const PROFILE_SPEEDS := [3.0, 3.8, 4.3, 5.0, 6.0] const ROUTINES_DIR := "user://routines" const EXPORTS_DIR := "user://exports" const EXPORT_SHEET_SCENE := preload("res://scenes/export/export_sheet.tscn") +const ELEMENT_CATALOG_SCRIPT := preload("res://src/core/rules/element_catalog.gd") const EXPORT_IMAGE_SIZE := Vector2i(2560, 1600) const AUTOSAVE_PATH := "user://autosave.tres" const SYNC_SETTINGS_PATH := "user://sync.cfg" @@ -109,6 +110,7 @@ const COMPACT_LAYOUT_WIDTH := 1280.0 @onready var element_dialog_type_option: OptionButton = %ElementDialogTypeOption @onready var element_code_edit: LineEdit = %ElementCodeEdit @onready var element_level_option: OptionButton = %ElementLevelOption +@onready var element_value_label: Label = %ElementValueLabel @onready var element_duration_spin: SpinBox = %ElementDurationSpin @onready var segment_label_dialog: ConfirmationDialog = %SegmentLabelDialog @onready var segment_label_edit: LineEdit = %SegmentLabelEdit @@ -149,6 +151,7 @@ var _direction: PathSegment.Direction = PathSegment.Direction.FORWARD var _edge: PathSegment.Edge = PathSegment.Edge.OUTSIDE var _element_type: PathSegment.ElementType = PathSegment.ElementType.JUMP var _element_level: int = 0 +var _element_catalog: ElementCatalog var _preset_speed: float = DEFAULT_SPEED_MPS var _current_path: String = "" var _dirty: bool = false @@ -174,6 +177,11 @@ var _sync_running: bool = false func _ready() -> void: autosave_timer.wait_time = AUTOSAVE_DELAY_SECONDS + _element_catalog = ELEMENT_CATALOG_SCRIPT.load_default() + if not _element_catalog.get_errors().is_empty(): + push_warning( + "Element catalog: %s" % ", ".join(_element_catalog.get_errors()) + ) _setup_tool_options() _setup_file_menu() _setup_playback_controls() @@ -396,11 +404,81 @@ func get_element_level() -> int: return _element_level +func get_element_catalog() -> ElementCatalog: + return _element_catalog + + +## Updates the Base-Value hint in the element inspector. Public so tests and +## callers that set the controls programmatically can refresh it explicitly. +func update_element_value_hint() -> void: + if element_value_label == null: + return + if _element_catalog == null: + element_value_label.text = "" + return + + var type_index := element_dialog_type_option.selected + var type: PathSegment.ElementType = PathSegment.ElementType.NONE + if type_index >= 0: + type = element_dialog_type_option.get_item_id(type_index) + var level := 0 + if element_level_option.selected >= 0: + level = element_level_option.get_item_id(element_level_option.selected) + var code := element_code_edit.text.strip_edges() + var source := "%s · %s" % [_element_catalog.season, _element_catalog.source] + element_value_label.tooltip_text = source + + if type == PathSegment.ElementType.NONE or code.is_empty(): + element_value_label.text = "Base Value: –" + return + + var value := _element_catalog.get_base_value(code, level, type) + if value < 0.0: + element_value_label.text = ( + "Base Value: – (Kürzel nicht im Katalog %s)" % _element_catalog.season + ) + return + element_value_label.text = ( + "Base Value: %s" % ("%.2f" % value).replace(".", ",") + ) + + func get_selected_element_caption() -> String: var segment := get_selected_segment() return segment.get_element_caption() if segment != null else "" +## Splits a canonical level suffix ("CCoSp4", "StSqB") into the level field so +## segments keep the family code and the level separate. Unknown codes and +## mismatched types are left untouched. +func _normalize_element_input( + type: PathSegment.ElementType, + code: String, + level: int +) -> Dictionary: + var cleaned := code.strip_edges().left(PathSegment.ELEMENT_CODE_MAX_LENGTH) + var clamped := clampi(level, 0, PathSegment.ELEMENT_MAX_LEVEL) + if ( + _element_catalog == null + or type == PathSegment.ElementType.NONE + or cleaned.length() < 2 + ): + return {"code": cleaned, "level": clamped} + + var suffix := _element_catalog.get_level_suffix(cleaned) + if suffix < 0: + return {"code": cleaned, "level": clamped} + + var family := cleaned.left(cleaned.length() - 1) + var definition := _element_catalog.find(family) + if definition == null or definition.element_type != type: + return {"code": cleaned, "level": clamped} + if not definition.has_level(suffix): + return {"code": cleaned, "level": clamped} + + return {"code": family, "level": suffix} + + ## Tags the selected segment with an element (or removes the tag). Returns true ## when the model changed. A negative [param duration] keeps the current stand ## time. @@ -420,6 +498,10 @@ func set_selected_element( var cleaned := code.strip_edges().left(PathSegment.ELEMENT_CODE_MAX_LENGTH) var clamped := clampi(level, 0, PathSegment.ELEMENT_MAX_LEVEL) + if type != PathSegment.ElementType.NONE: + var normalized := _normalize_element_input(type, cleaned, clamped) + cleaned = str(normalized["code"]) + clamped = int(normalized["level"]) var clamped_duration := -1.0 if type == PathSegment.ElementType.NONE: cleaned = "" @@ -482,10 +564,12 @@ func add_element_marker( segment.curve = curve segment.duration_seconds = 0.0 segment.timing_mode = PathSegment.TimingMode.SPEED + var input_level := _element_level if level < 0 else level + var normalized := _normalize_element_input(type, code, input_level) segment.set_element( type, - code, - _element_level if level < 0 else level + str(normalized["code"]), + int(normalized["level"]) ) segment.set_element_duration( float(ELEMENT_DEFAULT_DURATIONS.get(type, 0.0)) @@ -526,6 +610,20 @@ func _setup_element_controls() -> void: for level: int in range(1, PathSegment.ELEMENT_MAX_LEVEL + 1): element_level_option.add_item("Level %d" % level, level) + element_code_edit.text_changed.connect(_on_element_code_text_changed) + element_level_option.item_selected.connect(_on_element_value_option_selected) + element_dialog_type_option.item_selected.connect( + _on_element_value_option_selected + ) + + +func _on_element_code_text_changed(_text: String) -> void: + update_element_value_hint() + + +func _on_element_value_option_selected(_index: int) -> void: + update_element_value_hint() + func _on_element_type_selected(index: int) -> void: var type: PathSegment.ElementType = element_type_option.get_item_id(index) @@ -565,9 +663,10 @@ func _open_element_dialog() -> void: else "Sequenzbereiche nutzen die Segmentdauer in der Timing-Leiste" ) - element_dialog.popup_centered(Vector2i(520, 420)) + element_dialog.popup_centered(Vector2i(520, 460)) element_code_edit.grab_focus() element_code_edit.select_all() + update_element_value_hint() func _on_element_confirmed() -> void: diff --git a/rinkplanner/tests/README.md b/rinkplanner/tests/README.md index 0a3cbee..381d972 100644 --- a/rinkplanner/tests/README.md +++ b/rinkplanner/tests/README.md @@ -21,6 +21,9 @@ $GODOT --headless --path rinkplanner --import # Run model tests $GODOT --headless --path rinkplanner --script res://tests/run_model_tests.gd +# Run ISU element catalog tests +$GODOT --headless --path rinkplanner --script res://tests/run_rules_tests.gd + # Run canvas transform/geometry tests $GODOT --headless --path rinkplanner --script res://tests/run_canvas_tests.gd diff --git a/rinkplanner/tests/run_rules_tests.gd b/rinkplanner/tests/run_rules_tests.gd new file mode 100644 index 0000000..51ba368 --- /dev/null +++ b/rinkplanner/tests/run_rules_tests.gd @@ -0,0 +1,359 @@ +extends SceneTree + +## Headless tests for the ISU element catalog. +## +## Run with: +## godot --headless --path rinkplanner --script res://tests/run_rules_tests.gd + +const ElementDefinitionScript := preload("res://src/core/rules/element_definition.gd") +const ElementCatalogScript := preload("res://src/core/rules/element_catalog.gd") +const PathSegmentModel := preload("res://src/core/model/path_segment.gd") + +var _assertions: int = 0 +var _failures: PackedStringArray = PackedStringArray() +var _catalog: ElementCatalog + + +func _init() -> void: + _catalog = ElementCatalogScript.load_default() + + _test_catalog_metadata() + _test_jump_values() + _test_spin_values() + _test_sequence_values() + _test_lookup_rules() + _test_suggestions() + _test_segment_integration() + _test_invalid_catalogs() + _finish() + + +func _test_catalog_metadata() -> void: + _check(_catalog != null, "catalog loads") + _check( + _catalog.get_errors().is_empty(), + "catalog parses without errors (%s)" % ", ".join(_catalog.get_errors()) + ) + _check(_catalog.is_valid(), "catalog is valid") + _check(_catalog.season == "2025/26", "catalog season is 2025/26") + _check(_catalog.source.contains("2707"), "catalog names ISU communication 2707") + _check(_catalog.valid_from == "2025-07-01", "catalog valid from 2025-07-01") + _check(_catalog.get_definition_count() == 42, "catalog has 42 element families") + _check( + _catalog.get_codes(PathSegment.ElementType.JUMP).size() == 24, + "catalog has 24 jump families" + ) + _check( + _catalog.get_codes(PathSegment.ElementType.SPIN).size() == 16, + "catalog has 16 spin families" + ) + _check( + _catalog.get_codes(PathSegment.ElementType.SEQUENCE).size() == 2, + "catalog has 2 sequence families" + ) + + var seen: Dictionary[String, bool] = {} + for definition: ElementDefinition in _catalog.get_definitions(): + _check(definition.is_valid(), "'%s' is a valid definition" % definition.code) + _check(not seen.has(definition.code), "'%s' is unique" % definition.code) + seen[definition.code] = true + + +func _test_jump_values() -> void: + _check_approx(_catalog.get_base_value("1T"), 0.40, "1T base value") + _check_approx(_catalog.get_base_value("2A"), 3.30, "2A base value") + _check_approx(_catalog.get_base_value("3Lz"), 5.90, "3Lz base value") + _check_approx(_catalog.get_base_value("3A"), 8.00, "3A base value") + _check_approx(_catalog.get_base_value("4Lo"), 10.50, "4Lo base value") + _check_approx(_catalog.get_base_value("4A"), 12.50, "4A base value") + _check_approx( + _catalog.get_base_value("3Lz", 4), + 5.90, + "jump levels are ignored" + ) + _check_approx( + _catalog.get_base_value("3Lz", 0, PathSegment.ElementType.JUMP), + 5.90, + "jump lookup with matching type" + ) + _check_approx( + _catalog.get_base_value("3Lz", 0, PathSegment.ElementType.SPIN), + -1.0, + "jump lookup rejects a spin type" + ) + + var triple_lutz: ElementDefinition = _catalog.find("3Lz") + _check(triple_lutz != null, "3Lz family exists") + _check(triple_lutz.display_name == "Triple Lutz", "3Lz has a display name") + _check(not triple_lutz.is_leveled(), "jumps are not levelled") + _check( + triple_lutz.get_codes() == PackedStringArray(["3Lz"]), + "jump family has one canonical code" + ) + + +func _test_spin_values() -> void: + _check_approx(_catalog.get_base_value("USpB"), 1.00, "USpB base value") + _check_approx(_catalog.get_base_value("USp4"), 2.40, "USp4 base value") + _check_approx(_catalog.get_base_value("LSp4"), 2.70, "LSp4 base value") + _check_approx(_catalog.get_base_value("FCSp4"), 3.20, "FCSp4 base value") + _check_approx(_catalog.get_base_value("CCoSpB"), 1.70, "CCoSpB base value") + _check_approx(_catalog.get_base_value("CCoSp4"), 3.50, "CCoSp4 base value") + _check_approx( + _catalog.get_base_value("CCoSp", 4), + 3.50, + "spin lookup by family and level" + ) + _check_approx( + _catalog.get_base_value("CCoSp4", -1), + 3.50, + "spin lookup infers the level suffix" + ) + + var combination: ElementDefinition = _catalog.find("CCoSp") + _check(combination != null, "CCoSp family exists") + _check(combination.is_leveled(), "spins are levelled") + _check( + combination.get_codes() + == PackedStringArray(["CCoSpB", "CCoSp1", "CCoSp2", "CCoSp3", "CCoSp4"]), + "CCoSp exposes Base through level 4" + ) + _check( + ElementDefinitionScript.level_label(0) == "Base", + "level 0 is labelled Base" + ) + _check( + ElementDefinitionScript.level_label(3) == "Level 3", + "level 3 is labelled Level 3" + ) + + +func _test_sequence_values() -> void: + _check_approx(_catalog.get_base_value("StSqB"), 1.50, "StSqB base value") + _check_approx(_catalog.get_base_value("StSq3"), 3.30, "StSq3 base value") + _check_approx(_catalog.get_base_value("ChSq1"), 3.00, "ChSq1 base value") + _check_approx( + _catalog.get_base_value("ChSq"), + 3.00, + "single-level sequence resolves without a suffix" + ) + _check_approx( + _catalog.get_base_value("ChSq4"), + -1.0, + "unknown sequence level is rejected" + ) + + +func _test_lookup_rules() -> void: + _check(_catalog.find("3Lz") != null, "exact lookup works") + _check(_catalog.find(" 3lz ") != null, "lookup trims and ignores case") + _check(_catalog.find("CCoSp4") != null, "lookup accepts a level suffix") + _check(_catalog.find("StSqB") != null, "lookup accepts the Base suffix") + _check(_catalog.find("3X") == null, "unknown code returns null") + _check(_catalog.find("") == null, "empty code returns null") + _check(not _catalog.has_code("3X"), "unknown code is not reported as present") + _check( + _catalog.get_level_suffix("CCoSp4") == 4, + "a spin suffix is parsed as level 4" + ) + _check( + _catalog.get_level_suffix("StSqB") == 0, + "a Base suffix is parsed as level 0" + ) + _check( + _catalog.get_level_suffix("CCoSp") == -1, + "a family code has no level suffix" + ) + _check( + _catalog.get_level_suffix("3Lz") == -1, + "a jump code has no level suffix" + ) + _check_approx( + _catalog.get_base_value("CCoSp4", 2), + 3.50, + "a canonical suffix wins over the level argument" + ) + _check_approx( + _catalog.get_base_value("StSqB", 4), + 1.50, + "a Base suffix wins over a graded level argument" + ) + _check_approx( + _catalog.get_base_value("ChSq1", 0), + 3.00, + "an explicit sequence suffix wins over level 0" + ) + _check_approx( + _catalog.get_base_value("3X"), + -1.0, + "unknown code has no base value" + ) + _check_approx( + _catalog.get_base_value(""), + -1.0, + "empty code has no base value" + ) + + +func _test_suggestions() -> void: + var combined := _catalog.suggest(PathSegment.ElementType.SPIN, "ccosp", 8) + _check( + combined == PackedStringArray(["CCoSp"]), + "suggestions match a case-insensitive code prefix" + ) + _check( + _catalog.suggest(PathSegment.ElementType.JUMP, "axel", 8).size() == 4, + "suggestions match the display name" + ) + _check( + _catalog.suggest(PathSegment.ElementType.JUMP, "", 100).size() == 24, + "suggestions respect the element type filter" + ) + _check( + _catalog.suggest(PathSegment.ElementType.JUMP, "", 3).size() == 3, + "suggestions respect the limit" + ) + _check( + _catalog.suggest(PathSegment.ElementType.SPIN, "", 0).is_empty(), + "a zero limit returns no suggestions" + ) + _check( + _catalog.suggest(PathSegment.ElementType.SPIN, "3Lz", 8).is_empty(), + "suggestions do not cross element types" + ) + + +func _test_segment_integration() -> void: + var spin: PathSegment = PathSegmentModel.new() + spin.segment_id = "spin" + spin.curve = _make_point_curve(Vector2.ZERO) + spin.set_element(PathSegment.ElementType.SPIN, "CCoSp", 4) + _check_approx( + _catalog.get_segment_base_value(spin), + 3.50, + "segment integration resolves a spin" + ) + + var jump: PathSegment = PathSegmentModel.new() + jump.segment_id = "jump" + jump.curve = _make_point_curve(Vector2.ZERO) + jump.set_element(PathSegment.ElementType.JUMP, "3Lz", 2) + _check_approx( + _catalog.get_segment_base_value(jump), + 5.90, + "segment integration ignores jump levels" + ) + + var sequence: PathSegment = PathSegmentModel.new() + sequence.segment_id = "sequence" + sequence.curve = _make_point_curve(Vector2.ZERO) + sequence.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 3) + _check_approx( + _catalog.get_segment_base_value(sequence), + 3.30, + "segment integration resolves a sequence" + ) + + var untagged: PathSegment = PathSegmentModel.new() + untagged.segment_id = "untagged" + untagged.curve = _make_point_curve(Vector2.ZERO) + _check_approx( + _catalog.get_segment_base_value(untagged), + -1.0, + "untagged segments have no base value" + ) + + var coded: PathSegment = PathSegmentModel.new() + coded.segment_id = "coded" + coded.curve = _make_point_curve(Vector2.ZERO) + coded.set_element(PathSegment.ElementType.JUMP, "3Lz", 0) + coded.element_type = PathSegment.ElementType.SPIN + _check_approx( + _catalog.get_segment_base_value(coded), + -1.0, + "segment integration rejects a mismatched type" + ) + + +func _test_invalid_catalogs() -> void: + var missing := ElementCatalogScript.load_from("user://does-not-exist.json") + _check(not missing.is_valid(), "a missing catalog is invalid") + _check( + _contains_error(missing.get_errors(), "cannot open"), + "a missing catalog reports the path" + ) + + var path := "user://invalid_catalog.json" + var file := FileAccess.open(path, FileAccess.WRITE) + file.store_string( + '{"schema_version": 1, "season": "test", "source": "test", ' + + '"elements": [' + + '{"code": "3X", "name": "Unknown", "type": "lift", "base_value": 1.0},' + + '{"code": "Bad", "name": "Bad", "type": "spin", "base_values": {"Z": 1.0}},' + + '{"code": "Dup", "name": "First", "type": "jump", "base_value": 1.0},' + + '{"code": "dup", "name": "Second", "type": "jump", "base_value": 2.0}' + + "]}" + ) + file.close() + + var invalid := ElementCatalogScript.load_from(path) + _check(not invalid.is_valid(), "a catalog with bad data is invalid") + _check( + _contains_error(invalid.get_errors(), "unknown element type"), + "an unknown element type is reported" + ) + _check( + _contains_error(invalid.get_errors(), "invalid level key"), + "an invalid level key is reported" + ) + _check( + _contains_error(invalid.get_errors(), "duplicate element code"), + "a duplicate code is reported" + ) + _check( + invalid.find("Dup") != null, + "the first definition of a duplicate stays available" + ) + _check_approx( + invalid.get_base_value("Dup"), + 1.0, + "the first definition of a duplicate keeps its value" + ) + + +func _make_point_curve(point: Vector2) -> Curve2D: + var curve := Curve2D.new() + curve.add_point(point) + return curve + + +func _contains_error(errors: PackedStringArray, fragment: String) -> bool: + for error: String in errors: + if error.contains(fragment): + return true + return false + + +func _check(condition: bool, message: String) -> void: + _assertions += 1 + if not condition: + _failures.append(message) + + +func _check_approx(actual: float, expected: float, message: String) -> void: + _check( + absf(actual - expected) <= 0.001, + "%s (expected %.3f, got %.3f)" % [message, expected, actual] + ) + + +func _finish() -> void: + if _failures.is_empty(): + print("PASS: %d assertions" % _assertions) + quit(0) + return + + for failure: String in _failures: + printerr("FAIL: %s" % failure) + printerr("%d of %d assertions failed" % [_failures.size(), _assertions]) + quit(1) diff --git a/rinkplanner/tests/run_rules_tests.gd.uid b/rinkplanner/tests/run_rules_tests.gd.uid new file mode 100644 index 0000000..9b082a1 --- /dev/null +++ b/rinkplanner/tests/run_rules_tests.gd.uid @@ -0,0 +1 @@ +uid://byd1rcnu1mpnb diff --git a/rinkplanner/tests/run_whiteboard_tests.gd b/rinkplanner/tests/run_whiteboard_tests.gd index 4f5c28e..0635f21 100644 --- a/rinkplanner/tests/run_whiteboard_tests.gd +++ b/rinkplanner/tests/run_whiteboard_tests.gd @@ -720,7 +720,11 @@ func _run() -> void: "element code and level can be edited" ) _check( - spin.get_element_caption() == "CCoSp4 L3", + spin.element_code == "CCoSp" and spin.element_level == 4, + "a canonical level suffix is moved into the level field" + ) + _check( + spin.get_element_caption() == "CCoSp L4", "marker caption includes code and level" ) _check_approx( @@ -741,7 +745,7 @@ func _run() -> void: _check(controller.redo(), "element edit can be redone") spin = controller.get_active_section().get_segment_by_id(spin.segment_id) _check( - spin != null and spin.get_element_caption() == "CCoSp4 L3", + spin != null and spin.get_element_caption() == "CCoSp L4", "redo restores the element data" ) @@ -750,17 +754,54 @@ func _run() -> void: controller.element_button.pressed.emit() _check(controller.element_dialog.visible, "element button opens the dialog") _check( - controller.element_code_edit.text == "CCoSp4", - "element dialog is prefilled with the code" + controller.element_code_edit.text == "CCoSp", + "element dialog is prefilled with the normalized code" ) - controller.element_code_edit.text = "CCoSp3" + _check( + controller.element_level_option.get_item_id( + controller.element_level_option.selected + ) == 4, + "element dialog is prefilled with the normalized level" + ) + var catalog := controller.get_element_catalog() + _check(catalog != null and catalog.season == "2025/26", "controller loads the ISU catalog") + _check( + controller.element_value_label.text.contains("3,50"), + "element dialog shows the base value of the current code and level" + ) + + controller.element_code_edit.text = "CCoSp" + controller.element_level_option.select( + controller.element_level_option.get_item_index(2) + ) + controller.update_element_value_hint() + _check( + controller.element_value_label.text.contains("2,50"), + "base value follows a family code and level 2" + ) + + controller.element_code_edit.text = "CCoSp4" + controller.update_element_value_hint() + _check( + controller.element_value_label.text.contains("3,50"), + "a canonical suffix wins over the level control" + ) + + controller.element_code_edit.text = "3X" + controller.update_element_value_hint() + _check( + controller.element_value_label.text.contains("nicht im Katalog"), + "unknown codes are marked as not in the catalog" + ) + + controller.element_code_edit.text = "CCoSp" controller.element_level_option.select( controller.element_level_option.get_item_index(2) ) controller.element_duration_spin.value = 6.5 controller.element_dialog.confirmed.emit() _check( - controller.get_selected_element_caption() == "CCoSp3 L2", + controller.get_selected_element_caption() == "CCoSp L2", "element dialog applies code and level" ) _check_approx( diff --git a/tools/test.sh b/tools/test.sh index 977c594..b543410 100755 --- a/tools/test.sh +++ b/tools/test.sh @@ -22,6 +22,9 @@ fi "$GODOT" --headless --path "$PROJECT_DIR" \ --script res://tests/run_model_tests.gd +"$GODOT" --headless --path "$PROJECT_DIR" \ + --script res://tests/run_rules_tests.gd + "$GODOT" --headless --path "$PROJECT_DIR" \ --script res://tests/run_canvas_tests.gd