diff --git a/docs/architecture.md b/docs/architecture.md index 2fd0208..eb049f6 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -3,8 +3,8 @@ Stand: 2026-10-31 Grundlage: `rinkplanner/rinkplanner_definition_agent_guidelines.md` Übergeordnete Reihenfolge: `docs/roadmap.md` -Letzte Session: `docs/findings-2026-10-31-isu-katalog.md` -(Session davor: `docs/findings-2026-10-30-element-marker.md`) +Letzte Session: `docs/findings-2026-10-31-isu-levels.md` +(Session davor: `docs/findings-2026-10-31-isu-katalog.md`) ## 1. Leitentscheidung @@ -62,6 +62,8 @@ Implementiert in `rinkplanner/src/core/rules/`: | :--- | :--- | | `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 | +| `ElementFeature` | Level-Feature mit Zählgrenze und Programm-Flag | +| `ElementLevelRules` | saisonale Feature-Sätze, Pflichtfeatures und Level-Berechnung | ### Entscheidungen @@ -117,6 +119,15 @@ 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. +**D9 – Level-Features sind Daten, das Level bleibt eine Autorengröße.** +`ElementLevelRules` liest eine eigene saisonale JSON-Datei mit Feature-Sätzen +und Schwellen. Ausgewählte Features liegen als Codes am Segment +(`element_features`); Duplikate sind erlaubt, damit z. B. zwei schwierige +Variationen zwei Features zählen. Der Inspector berechnet daraus ein Level +und zeigt es an, ersetzt aber das manuell gewählte `element_level` nicht +stillschweigend. So bleiben Altdaten und bewusste Overrides sichtbar, und die +spätere Validierung kann Abweichungen melden. + ## 4. View- und Controller-Grenzen - **View** (`Node2D`/`Control`) liest das Modell und zeichnet. Sie verändert @@ -161,6 +172,10 @@ Exporte aufgenommen. 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. + Der Button **Features (n)** öffnet die Checkbox-Liste der Level-Features + (Pirouetten, Schrittsequenzen) und übernimmt die Auswahl undo-fähig. Ein + Hinweis zeigt Feature-Anzahl, abgeleitetes Level und eine Abweichung zum + gewählten Level; das gewählte Level bleibt autoritativ. 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 @@ -313,13 +328,17 @@ Aktueller Stand: - **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. +- **Level-Features:** 47 Assertions für Feature-Metadaten, Schwellen, + schwierige Variationen, Level-4-Voraussetzungen, Pflichtfeatures bei + Schrittsequenzen, feste Level (`ChSq`), Feature-Validierung und die + Speicherung am Segment. - **Canvas:** 90 Assertions für Meter→Pixel-Mapping, Fit/Zoom/Pan, Rink-Kontur und die reine Bogen-Geometrie. -- **Whiteboard:** 208 Assertions für Controller-Verdrahtung, Segmenterzeugung, +- **Whiteboard:** 228 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 und Base-Value-Hinweis, Verschieben, - Löschen), Section-Verwaltung, + Typwechsel, Inspector inkl. Standzeit, Base-Value- und Feature-Hinweis, + Feature-Menü, 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-levels.md b/docs/findings-2026-10-31-isu-levels.md new file mode 100644 index 0000000..0671235 --- /dev/null +++ b/docs/findings-2026-10-31-isu-levels.md @@ -0,0 +1,105 @@ +# Findings – Session: ISU-Level-Features (2026-10-31) + +Ergänzung zu `docs/findings-2026-10-31-isu-katalog.md`. +Nach dem Base-Value-Katalog folgt die zweite ISU-Ausbaustufe: Level-Features +für Pirouetten und Schrittsequenzen samt Level-Berechnung und Auswahl im +Element-Inspector. + +## Ergebnis + +| Ziel | Ergebnis | +| :--- | :--- | +| Feature-Daten | `isu_levels_2025_26.json` aus ISU Communication No. 2701 | +| Feature-Modell | `ElementFeature`, `ElementLevelRules` in `src/core/rules/` | +| Umfang | 14 Pirouetten-Features, 4 Schrittsequenz-Features | +| Level-Berechnung | 1 Feature → Level 1 … 4 Features → Level 4; Level-4-Voraussetzungen | +| Speicherung | `PathSegment.element_features` (Codes, Duplikate erlaubt) | +| Bedienung | Button „Features (n)“ mit Checkbox-Menü, Hinweis auf abgeleitetes Level | +| Tests | 833 Assertions gesamt, `./tools/test.sh` grün (neu: 47 Level-Tests) | + +## Quelle und Regeln + +- ISU Communication No. 2701, *Single & Pair Skating – Levels of Difficulty + and Guidelines for marking Grade of Execution and Program Components, + Season 2025/26* (ersetzt Communication 2623). +- Schwellen: 1 Feature → Level 1, 2 → Level 2, 3 → Level 3, 4 oder mehr → + Level 4; ohne Feature Base. +- **Pirouetten:** 14 Features. Schwierige Variationen zählen höchstens zweimal + pro Pirouette. Für Level 4 ist zusätzlich eines von sechs Features nötig: + schwieriger Positionswechsel, schwieriger Ausgang, klare Kantenänderung, + beide Richtungen, klare Temposteigerung oder schwieriger Flug-Eingang. +- **Schrittsequenzen:** 4 Features. Feature 1 (Vielfalt schwieriger Schritte + und Drehungen) ist Pflicht; ohne sie bleibt die Sequenz Base, auch wenn + andere Features gesetzt sind. +- **Choreografische Sequenz (`ChSq`):** fest Level 1, unabhängig von Features. +- **Sprünge:** nicht levelbar. + +## Entscheidungen + +- **Features sind Codes am Segment.** `element_features` ist eine + `PackedStringArray`; Duplikate sind erlaubt, damit zwei schwierige + Variationen als zwei Features zählen. Die Reihenfolge bleibt erhalten. +- **Typwechsel leert die Auswahl.** Features sind typabhängig; `set_element` + verwirft sie beim Wechsel des Elementtyps und beim Entfernen des Elements. +- **Das Level bleibt eine Autorengröße.** Die Berechnung erzeugt nur einen + Hinweis (`Features: 2 · Level 2 · gewählt: Level 4`). Der Inspector ändert + das gewählte Level nicht stillschweigend. So bleiben Altdaten und bewusste + Overrides sichtbar; die Validierung kann später Abweichungen melden. +- **Eigene JSON-Datei.** Level-Features stammen aus einer anderen + Communication als die Base Values und ändern sich unabhängig. Beide Dateien + tragen Saison, Quelle und Gültigkeitsdatum. +- **PopupMenu statt Unterdialog.** Der Button öffnet eine Checkbox-Liste am + Button. `hide_on_checkable_item_selection` ist aus, damit mehrere Features + ohne erneutes Öffnen gewählt werden können. Checkable PopupMenu-Einträge + toggeln sich in Godot nicht selbst; der Controller toggelt im + `id_pressed`-Handler. +- **Auswahl wird beim Schließen übernommen.** `popup_hide` sammelt die + markierten Einträge und ruft `set_selected_element_features`; die Änderung + ist undo-fähig und dirty-markierend. + +## Bedienung + +- Im Element-Inspector steht unter dem Base Value der Button `Features (n)`. +- Bei Sprüngen ist er deaktiviert und der Hinweis erklärt, dass Sprünge keine + Level-Features haben. Bei Sequenzen ohne Kürzel oder unbekanntem Kürzel + bleibt er ebenfalls deaktiviert. +- Das Menü zeigt alle Features des Typs; schwierige Variationen erscheinen + zweimal (`1/2`, `2/2`). Tooltips erklären die Features. +- „Auswahl zurücksetzen“ entfernt alle Haken. +- Der Hinweis darunter nennt Feature-Anzahl, abgeleitetes Level, eine + Abweichung zum gewählten Level und ggf. ignorierte Features. +- Fehlt bei einer Schrittsequenz das Pflichtfeature, steht dort + „Pflichtfeature fehlt: variety_of_turns“. + +## Grenzen + +1. **Programmweite Grenzen:** `once_per_program` ist in den Daten, wird aber + noch nicht ausgewertet. Features 2–9 und 11–14 zählen laut ISU nur beim + ersten Versuch im Programm. +2. **Maximal zwei Features pro Fuß:** Bei Pirouetten mit Fußwechsel ist die + Ausbeute pro Fuß begrenzt. Das Modell kennt keine Füße und kann das nicht + prüfen. +3. **Feature-Kombinationen:** Die Regel „Feature nicht zusammen mit einer + bereits verwendeten Variationsposition“ ist nicht modelliert. +4. **Adult-Abweichungen:** Die Datei enthält die regulären ISU-Regeln, keine + Adult-spezifischen Erleichterungen. +5. **GOE und Varianten:** GOE-Tabellen, `V`-, `q`-, `e`-, `!`-, `<`- und + `<<`-Varianten fehlen weiterhin. + +## Tests + +Neu: `tests/run_level_tests.gd` (47 Assertions) + +- Metadaten, Saison, Quelle und Feature-Anzahl +- Schwellen 0–4 Features, Duplikate schwieriger Variationen, Ignorieren + überzähliger Variationen +- Level-4-Voraussetzung: vier Features ohne Spezialfeature bleiben Level 3 +- Pflichtfeature der Schrittsequenz, `ChSq` fest Level 1, Sprünge ohne Level +- `validate_selection` für unbekannte, überzählige und fehlende Features +- Segment-Speicherung, Trimmen, Kappung, Leeren bei Typwechsel/Entfernen + +Erweitert: `tests/run_whiteboard_tests.gd` (208 → 228 Assertions) prüft +Feature-Zuweisung, Hinweis, Menüaufbau, Toggle, Undo/Redo und Leeren. + +Visuell geprüft über `tests/manual/capture_elements.gd ... features` bei +1400 × 876 und 1024 × 768. diff --git a/docs/isu-rules.md b/docs/isu-rules.md index 70a7caa..b2cffe8 100644 --- a/docs/isu-rules.md +++ b/docs/isu-rules.md @@ -1,9 +1,15 @@ -# ISU-Regelwerk – Elementkatalog +# ISU-Regelwerk – Elementkatalog und Level-Features 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) + +Quellen: + +- ISU Communication No. 2707, *Single & Pair Skating – Scale of Values + valid as of July 1, 2025* (ersetzt Communication 2656) +- ISU Communication No. 2701, *Single & Pair Skating – Levels of Difficulty + and Guidelines for marking Grade of Execution and Program Components, + Season 2025/26* (ersetzt Communication 2623) ## Zweck @@ -17,20 +23,25 @@ Aktuell abgedeckt: - **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) +- **Level-Features** für Pirouetten (14) und Schrittsequenzen (4) inklusive + Level-Berechnung nach Feature-Anzahl 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. +und -folgen, Paarlauf-Hebungen/Twists/Throws sowie Eistanz-Elemente. ## Dateien | Datei | Inhalt | | :--- | :--- | -| `rinkplanner/src/core/rules/data/isu_sov_2025_26.json` | aktiver Katalog | +| `rinkplanner/src/core/rules/data/isu_sov_2025_26.json` | Katalog mit Base Values | +| `rinkplanner/src/core/rules/data/isu_levels_2025_26.json` | Level-Features und Schwellen | | `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 | +| `rinkplanner/src/core/rules/element_level_rules.gd` | Feature-Lookup und Level-Berechnung | +| `rinkplanner/src/core/rules/element_feature.gd` | ein Level-Feature mit Zählgrenzen | +| `rinkplanner/tests/run_rules_tests.gd` | Katalog-Tests inkl. Stichproben | +| `rinkplanner/tests/run_level_tests.gd` | Feature- und Level-Tests | ## Datenformat @@ -95,6 +106,43 @@ catalog.suggest(PathSegment.ElementType.SPIN, "ccosp", 8) - Der Base Value wird **nicht** am Segment gespeichert. Das Segment trägt nur `element_code` und `element_level`; die Anzeige fragt den Katalog. +## Level-Features + +Die Level-Regeln stehen in einer eigenen JSON-Datei, weil sie aus einer +anderen ISU-Communication stammen und sich unabhängig von den Base Values +ändern können. Pro Elementtyp gibt es Feature-Definitionen, Pflichtfeatures +und – bei Pirouetten – die Menge der Features, von denen mindestens eines für +Level 4 nötig ist. + +| Elementtyp | Features | Besonderheit | +| :--- | :--- | :--- | +| Pirouette | 14 | Max. 2 schwierige Variationen pro Pirouette; Level 4 verlangt eines von 6 bestimmten Features | +| Schrittsequenz | 4 | Feature 1 (Vielfalt) ist Pflicht; ohne sie bleibt die Sequenz Base | +| `ChSq` | – | Fest Level 1 | +| Sprung | – | Nicht levelbar | + +Die Schwelle ist für beide Typen gleich: 1 Feature → Level 1, 2 → Level 2, +3 → Level 3, 4 oder mehr → Level 4. Ohne Feature bleibt das Element Base. +`ElementLevelRules.calculate_level()` liefert neben dem Level auch die +gezählten, ignorierten und fehlenden Pflichtfeatures: + +```gdscript +var rules := ElementLevelRules.load_default() +var result := rules.calculate_level( + PathSegment.ElementType.SPIN, + "CCoSp", + PackedStringArray(["difficult_variation", "difficult_exit"]) +) +# result.level == 2, result.counted_features == 2 +``` + +Das Segment speichert die Auswahl als `element_features` +(`PackedStringArray`). Duplikate sind erlaubt, damit zwei schwierige +Variationen als zwei Features zählen. Die Daten enthalten außerdem +`once_per_program` (Feature zählt nur beim ersten Versuch im Programm) und +`max_per_element`. Die Programmprüfung und die Begrenzung „max. zwei Features +pro Fuß“ sind noch nicht umgesetzt. + ## Bedienung Der Element-Inspector zeigt unter der Level-Auswahl `Base Value: 3,50`. @@ -102,6 +150,13 @@ 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. +Darunter liegt der Button **Features (n)**. Er öffnet eine Checkbox-Liste mit +den Features des Elementtyps; die Auswahl wird beim Schließen übernommen und +ist undo-fähig. Ein Hinweis zeigt die gezählten Features, das daraus +abgeleitete Level und – bei Abweichung – das manuell gewählte Level, z. B. +`Features: 2 · Level 2 · gewählt: Level 4`. Das gewählte Level bleibt +autoritativ; die Feature-Prüfung ersetzt es nicht stillschweigend. + ## Neue Saison einpflegen 1. Neue ISU-Communication (Scale of Values) beschaffen und als JSON nach dem @@ -110,16 +165,20 @@ nennt Saison und Quelle. 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. +5. Neue Level-Communication (Levels of Difficulty) als + `isu_levels_2026_27.json` anlegen, `ElementLevelRules.DEFAULT_PATH` + umstellen und `tests/run_level_tests.gd` anpassen. +6. `./tools/test.sh` ausführen. +7. Die alte Datei kann für Nachvollziehbarkeit im Repo bleiben; aktiv ist + immer genau eine Datei pro Regelart. -Die JSON-Datei wird über `include_filter="*.json"` in allen Export-Presets +Die JSON-Dateien werden über `include_filter="*.json"` in allen Export-Presets mit ausgeliefert. ## Nächste Ausbaustufen -- Level-/Feature-Prüfung (welche Features ergeben welches Level) +- Programmweite Feature-Grenzen (`once_per_program`, max. 2 Features pro Fuß) +- Abgleich zwischen gewähltem Level und Feature-Ergebnis in der Validierung - GOE-Tabellen und `V`-/Unterrotations-Varianten - Sprungkombinationen und -folgen als zusammengesetzte Elemente - Programmvalidierung (erlaubte Elementanzahl, Wiederholungen, Adult-Regeln) diff --git a/docs/roadmap.md b/docs/roadmap.md index 6449a4f..6ce9ab5 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -1,6 +1,6 @@ # Rinkplanner – Roadmap -Stand: 2026-10-31 (ISU-Katalog begonnen; Sync-Komfort und UI-Refactoring zurückgestellt) +Stand: 2026-10-31 (ISU-Katalog und Level-Features; 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`. @@ -116,8 +116,11 @@ Voraussetzung für Phase 1. - [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 +- [x] Features und Kriterien für die Level-Vergabe + – Pirouetten (14 Features) und Schrittsequenzen (4 Features), + Level-Berechnung und Auswahl im Inspector; Details in `docs/isu-rules.md` - [ ] Validierung von Elementen und Kombinationen +- [ ] Programmweite Feature-Grenzen (`once_per_program`, max. 2 pro Fuß) - [ ] Optional: Kürzelvorschläge im Inspector aus `suggest()` - [ ] Optional: GOE-Tabellen sowie `V`-/Unterrotationsvarianten @@ -143,11 +146,11 @@ fachlichen Validierung angefasst. Übernahme des Feedbacks der Tester Die Reihenfolge ist bewusst: native Builds, Datenaustausch und Element-Marker -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. +sind erledigt. Im PoC läuft jetzt das ISU-Regelwerk – Katalog und +Level-Features stehen, als Nächstes folgt die 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/scenes/whiteboard/whiteboard.tscn b/rinkplanner/scenes/whiteboard/whiteboard.tscn index d924a70..26fef66 100644 --- a/rinkplanner/scenes/whiteboard/whiteboard.tscn +++ b/rinkplanner/scenes/whiteboard/whiteboard.tscn @@ -622,6 +622,23 @@ 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="ElementFeaturesButton" type="Button" parent="ElementDialog/ElementBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(0, 56) +layout_mode = 2 +theme_override_font_sizes/font_size = 17 +text = "Features (0)" +tooltip_text = "Level-Features des ausgewählten Elements erfassen" +disabled = true + +[node name="ElementFeatureHint" type="Label" parent="ElementDialog/ElementBox"] +unique_name_in_owner = true +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 +autowrap_mode = 3 + [node name="ElementDurationLabel" type="Label" parent="ElementDialog/ElementBox"] layout_mode = 2 theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) @@ -910,3 +927,8 @@ layout_mode = 2 theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) theme_override_font_sizes/font_size = 12 text = "Ziel: user://exports" + +[node name="ElementFeatureMenu" type="PopupMenu" parent="."] +unique_name_in_owner = true +hide_on_item_selection = false +hide_on_checkable_item_selection = false diff --git a/rinkplanner/src/core/model/path_segment.gd b/rinkplanner/src/core/model/path_segment.gd index 9f89cf7..974b397 100644 --- a/rinkplanner/src/core/model/path_segment.gd +++ b/rinkplanner/src/core/model/path_segment.gd @@ -39,6 +39,7 @@ enum ElementType { const ELEMENT_CODE_MAX_LENGTH := 24 const ELEMENT_MAX_LEVEL := 4 const ELEMENT_MAX_DURATION_SECONDS := 120.0 +const ELEMENT_MAX_FEATURES := 16 @export var segment_id: String = "" @export var curve: Curve2D @@ -53,6 +54,10 @@ const ELEMENT_MAX_DURATION_SECONDS := 120.0 ## ISU level: 0 is "Base", 1–4 are the graded levels. Only used by spins and ## sequences; jumps keep 0. @export var element_level: int = 0 +## Selected level features (codes from the season's level rules). Duplicates +## are allowed for features that can count more than once, e.g. difficult +## variations in a spin. +@export var element_features: PackedStringArray = PackedStringArray() ## Stand time of a point marker in seconds (jump air time, spin rotation). It is ## independent of the geometry; ranges use [member duration_seconds] instead. @export var element_duration_seconds: float = 0.0 @@ -135,16 +140,39 @@ static func element_type_name(type: ElementType) -> String: ## Applies an element in one step and keeps code and level within their bounds. +## Changing the element type clears the feature selection because features are +## type-specific. func set_element(type: ElementType, code: String, level: int) -> void: + var previous_type := element_type element_type = type if type == ElementType.NONE: element_code = "" element_level = 0 + element_features = PackedStringArray() return + if type != previous_type: + element_features = PackedStringArray() element_code = code.strip_edges().left(ELEMENT_CODE_MAX_LENGTH) element_level = clampi(level, 0, ELEMENT_MAX_LEVEL) +## Replaces the selected level features. Empty codes are dropped, order is +## preserved and duplicates are kept for multi-count features. +func set_element_features(features: PackedStringArray) -> void: + if element_type == ElementType.NONE: + element_features = PackedStringArray() + return + var cleaned := PackedStringArray() + for raw: String in features: + var code := raw.strip_edges() + if code.is_empty(): + continue + cleaned.append(code) + if cleaned.size() >= ELEMENT_MAX_FEATURES: + break + element_features = cleaned + + ## Short caption for the canvas and exports, e.g. "3Lz" or "CCoSp4 L3". func get_element_caption() -> String: var code := element_code.strip_edges() @@ -200,6 +228,19 @@ func validate() -> PackedStringArray: ) if element_type == ElementType.NONE and not element_code.strip_edges().is_empty(): errors.append("element_code needs an element_type") + if element_type == ElementType.NONE and not element_features.is_empty(): + errors.append("element_features need an element_type") + if element_features.size() > ELEMENT_MAX_FEATURES: + errors.append( + "element_features must not exceed %d entries" % ELEMENT_MAX_FEATURES + ) + for feature: String in element_features: + if feature.strip_edges().is_empty(): + errors.append("element_features must not contain empty codes") + break + if feature != feature.strip_edges(): + errors.append("element_features must be trimmed") + break if ( element_duration_seconds < 0.0 or element_duration_seconds > ELEMENT_MAX_DURATION_SECONDS diff --git a/rinkplanner/src/core/rules/data/isu_levels_2025_26.json b/rinkplanner/src/core/rules/data/isu_levels_2025_26.json new file mode 100644 index 0000000..decf284 --- /dev/null +++ b/rinkplanner/src/core/rules/data/isu_levels_2025_26.json @@ -0,0 +1,163 @@ +{ + "schema_version": 1, + "season": "2025/26", + "discipline": "Single Skating", + "valid_from": "2025-07-01", + "source": "ISU Communication No. 2701, Levels of Difficulty and Guidelines for marking Grade of Execution and Program Components, Season 2025/26", + "levels": [ + { "level": 1, "min_features": 1 }, + { "level": 2, "min_features": 2 }, + { "level": 3, "min_features": 3 }, + { "level": 4, "min_features": 4 } + ], + "fixed_levels": { + "ChSq": 1 + }, + "types": { + "spin": { + "required_features": [], + "level4_requires_any": [ + "difficult_position_change", + "difficult_exit", + "change_of_edge", + "both_directions", + "increase_speed", + "difficult_flying_entry" + ], + "features": [ + { + "code": "difficult_variation", + "name": "Schwierige Variation", + "description": "Schwierige Variation einer Grundposition; höchstens zwei zählen pro Pirouette.", + "max_per_element": 2, + "once_per_program": false + }, + { + "code": "change_foot_jump", + "name": "Fußwechsel per Sprung", + "description": "Fußwechsel mit einem Sprung ausgeführt.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "jump_in_spin", + "name": "Sprung in der Pirouette", + "description": "Sprung innerhalb der Pirouette ohne Fußwechsel.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "difficult_position_change", + "name": "Schwieriger Positionswechsel", + "description": "Schwieriger Positionswechsel auf demselben Fuß.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "difficult_entrance", + "name": "Schwieriger Eingang", + "description": "Schwieriger Eingang in die Pirouette.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "difficult_exit", + "name": "Schwieriger Ausgang", + "description": "Schwieriger Ausgang aus der Pirouette.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "change_of_edge", + "name": "Klare Kantenänderung", + "description": "Klare Kantenänderung in Sit, Camel, Layback, Biellmann oder schwieriger Upright-Variation.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "both_directions", + "name": "Beide Richtungen", + "description": "Beide Drehrichtungen unmittelbar nacheinander in Sit, Camel, Layback oder schwieriger Upright-Variation.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "increase_speed", + "name": "Klare Temposteigerung", + "description": "Klare Temposteigerung in Camel, Sit, Layback, Biellmann oder schwieriger Upright-Variation (nicht Crossfoot).", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "eight_revolutions", + "name": "8 Umdrehungen ohne Wechsel", + "description": "Mindestens 8 Umdrehungen ohne Wechsel von Position, Variation, Fuß oder Kante.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "difficult_flying_entry", + "name": "Schwieriger Flug-Eingang", + "description": "Schwierige Variation des fliegenden Eingangs bei Flugpirouetten.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "difficult_blade", + "name": "Schwieriges Klingenmerkmal", + "description": "Schwieriges Klingenmerkmal in Camel, Sit, Layback, Biellmann oder schwieriger Upright-Variation.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "layback_change", + "name": "Layback-Positionswechsel", + "description": "Layback: klarer Wechsel rückwärts-seitwärts oder umgekehrt, mindestens 2 Umdrehungen je Position.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "layback_biellmann", + "name": "Biellmann nach Layback", + "description": "Layback: Biellmann-Position nach dem Layback (SP 8 Umdrehungen, Advanced Novice 6).", + "max_per_element": 1, + "once_per_program": true + } + ] + }, + "sequence": { + "required_features": ["variety_of_turns"], + "level4_requires_any": [], + "features": [ + { + "code": "variety_of_turns", + "name": "Vielfalt schwieriger Schritte und Drehungen", + "description": "Mindest-, einfache, volle Vielfalt bzw. Komplexität schwieriger Schritte und Drehungen (verpflichtend).", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "both_rotations", + "name": "Drehungen in beide Richtungen", + "description": "Drehungen in beide Richtungen mit voller Körperdrehung über mindestens je 1/3 des Musters.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "body_movements", + "name": "Körperbewegungen", + "description": "Körperbewegungen über mindestens 1/3 des Musters.", + "max_per_element": 1, + "once_per_program": true + }, + { + "code": "turn_combinations", + "name": "Zwei Drehungs-Kombinationen", + "description": "Zwei Kombinationen aus je 3 schwierigen Drehungen auf verschiedenen Füßen im durchgehenden Fluss.", + "max_per_element": 1, + "once_per_program": true + } + ] + } + } +} diff --git a/rinkplanner/src/core/rules/element_feature.gd b/rinkplanner/src/core/rules/element_feature.gd new file mode 100644 index 0000000..d2f5478 --- /dev/null +++ b/rinkplanner/src/core/rules/element_feature.gd @@ -0,0 +1,34 @@ +class_name ElementFeature +extends Resource + +## One level feature from the ISU Levels of Difficulty communication. +## +## Features are season-specific data. A feature can count once per element or +## several times (e.g. difficult variations in a spin). The once-per-program +## flag is stored for later program validation; the current level calculation +## evaluates one element at a time. + +@export var code: String = "" +@export var display_name: String = "" +@export var description: String = "" +## Maximum times this feature counts within one element. +@export var max_per_element: int = 1 +## Only the first attempt in a program counts. Not enforced per element yet. +@export var once_per_program: bool = true + + +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 max_per_element <= 0: + errors.append("max_per_element must be positive") + + return errors + + +func is_valid() -> bool: + return validate().is_empty() diff --git a/rinkplanner/src/core/rules/element_feature.gd.uid b/rinkplanner/src/core/rules/element_feature.gd.uid new file mode 100644 index 0000000..7713b70 --- /dev/null +++ b/rinkplanner/src/core/rules/element_feature.gd.uid @@ -0,0 +1 @@ +uid://dt4yhcekedj6j diff --git a/rinkplanner/src/core/rules/element_level_rules.gd b/rinkplanner/src/core/rules/element_level_rules.gd new file mode 100644 index 0000000..fd2cfcc --- /dev/null +++ b/rinkplanner/src/core/rules/element_level_rules.gd @@ -0,0 +1,376 @@ +class_name ElementLevelRules +extends RefCounted + +## Season-specific ISU level rules for single skating. +## +## The rules answer one question: how many level features does an element have, +## and which level follows from them? They are pure data plus a calculator and +## stay independent of the whiteboard. Program-wide limits (a feature counting +## only once per program, maximum features per foot) are stored in the data but +## not enforced here yet. + +const DEFAULT_PATH := "res://src/core/rules/data/isu_levels_2025_26.json" +const SUPPORTED_SCHEMA_VERSION := 1 +const MAX_LEVEL := PathSegment.ELEMENT_MAX_LEVEL + +const TYPE_BY_NAME := { + "jump": PathSegment.ElementType.JUMP, + "spin": PathSegment.ElementType.SPIN, + "sequence": PathSegment.ElementType.SEQUENCE, +} + +## Result of evaluating one element's selected features. +class LevelResult extends RefCounted: + var level: int = 0 + var counted_features: int = 0 + var ignored_features: PackedStringArray = PackedStringArray() + var missing_required: PackedStringArray = PackedStringArray() + + func has_level() -> bool: + return level > 0 + + +var schema_version: int = 0 +var season: String = "" +var discipline: String = "" +var valid_from: String = "" +var source: String = "" + +var _thresholds: Array[Dictionary] = [] +var _features_by_type: Dictionary[int, Array] = {} +var _features_by_code: Dictionary[int, Dictionary] = {} +var _required_by_type: Dictionary[int, PackedStringArray] = {} +var _level4_by_type: Dictionary[int, PackedStringArray] = {} +var _fixed_levels: Dictionary[String, int] = {} +var _errors: PackedStringArray = PackedStringArray() + + +static func load_default() -> ElementLevelRules: + return load_from(DEFAULT_PATH) + + +static func load_from(path: String) -> ElementLevelRules: + var rules := ElementLevelRules.new() + rules._parse_file(path) + return rules + + +## All features for one element type, in file order. +func get_features(type: PathSegment.ElementType) -> Array[ElementFeature]: + var result: Array[ElementFeature] = [] + if not _features_by_type.has(type): + return result + for feature: ElementFeature in _features_by_type[type]: + result.append(feature) + return result + + +func get_feature( + type: PathSegment.ElementType, + code: String +) -> ElementFeature: + if not _features_by_code.has(type): + return null + return _features_by_code[type].get(_normalize(code), null) + + +func get_required_features(type: PathSegment.ElementType) -> PackedStringArray: + if not _required_by_type.has(type): + return PackedStringArray() + return _required_by_type[type].duplicate() + + +func get_level4_features(type: PathSegment.ElementType) -> PackedStringArray: + if not _level4_by_type.has(type): + return PackedStringArray() + return _level4_by_type[type].duplicate() + + +func get_thresholds() -> Array[Dictionary]: + var copy: Array[Dictionary] = [] + copy.assign(_thresholds) + return copy + + +## Evaluates the selected feature codes for one element. Unknown features and +## over-limit repetitions are reported in [member LevelResult.ignored_features] +## instead of raising the level. A fixed-level element (ChSq) short-circuits. +func calculate_level( + type: PathSegment.ElementType, + code: String, + features: PackedStringArray +) -> LevelResult: + var result := LevelResult.new() + var key := _normalize(code) + if _fixed_levels.has(key): + if type == PathSegment.ElementType.SEQUENCE: + result.level = _fixed_levels[key] + return result + + if not _features_by_type.has(type): + result.ignored_features = features.duplicate() + return result + + var definitions: Dictionary = _features_by_code[type] + var counts: Dictionary[String, int] = {} + for raw: String in features: + var feature_code := _normalize(raw) + if feature_code.is_empty(): + continue + if not definitions.has(feature_code): + _append_unique(result.ignored_features, raw) + continue + var feature: ElementFeature = definitions[feature_code] + var used: int = counts.get(feature_code, 0) + if used >= feature.max_per_element: + _append_unique(result.ignored_features, raw) + continue + counts[feature_code] = used + 1 + result.counted_features += 1 + + for required: String in _required_by_type.get(type, PackedStringArray()): + if not counts.has(required): + result.missing_required.append(required) + + if not result.missing_required.is_empty(): + return result + + result.level = _level_for_count(result.counted_features) + if result.level == MAX_LEVEL: + var level4_features: PackedStringArray = _level4_by_type.get( + type, + PackedStringArray() + ) + if not level4_features.is_empty() and not _contains_any(counts, level4_features): + result.level = MAX_LEVEL - 1 + return result + + +## Checks a feature selection for unknown codes and over-limit repetitions. +## Missing required features are reported when the selection is non-empty. +func validate_selection( + type: PathSegment.ElementType, + features: PackedStringArray +) -> PackedStringArray: + var errors := PackedStringArray() + var definitions: Dictionary = _features_by_code.get(type, {}) + var counts: Dictionary[String, int] = {} + + for raw: String in features: + var feature_code := _normalize(raw) + if feature_code.is_empty(): + errors.append("feature code must not be empty") + continue + if not definitions.has(feature_code): + errors.append("unknown feature '%s' for element type" % raw) + continue + var feature: ElementFeature = definitions[feature_code] + var used: int = counts.get(feature_code, 0) + if used >= feature.max_per_element: + errors.append( + "feature '%s' is selected more than %d time(s)" + % [raw, feature.max_per_element] + ) + continue + counts[feature_code] = used + 1 + + if not features.is_empty(): + for required: String in _required_by_type.get(type, PackedStringArray()): + if not counts.has(required): + errors.append("required feature '%s' is missing" % required) + + return errors + + +func get_errors() -> PackedStringArray: + return _errors.duplicate() + + +func validate() -> PackedStringArray: + var errors := _errors.duplicate() + if schema_version != SUPPORTED_SCHEMA_VERSION: + errors.append( + "unsupported level-rules schema %d (expected %d)" + % [schema_version, SUPPORTED_SCHEMA_VERSION] + ) + if season.strip_edges().is_empty(): + errors.append("level-rules season must not be empty") + if source.strip_edges().is_empty(): + errors.append("level-rules source must not be empty") + if _thresholds.is_empty(): + errors.append("level-rules thresholds must not be empty") + if _features_by_type.is_empty(): + errors.append("level-rules contains no element types") + 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 level rules '%s'" % path) + return + + var json := JSON.new() + var error := json.parse(file.get_as_text()) + if error != OK: + _errors.append( + "invalid level-rules JSON at line %d: %s" + % [json.get_error_line(), json.get_error_message()] + ) + return + + if typeof(json.data) != TYPE_DICTIONARY: + _errors.append("level-rules 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() + + _parse_thresholds(data.get("levels", [])) + _parse_fixed_levels(data.get("fixed_levels", {})) + + var types: Variant = data.get("types", {}) + if typeof(types) != TYPE_DICTIONARY: + _errors.append("level-rules 'types' must be an object") + return + for type_name: Variant in types as Dictionary: + var type_key := str(type_name).strip_edges().to_lower() + if not TYPE_BY_NAME.has(type_key): + _errors.append("unknown element type '%s' in level rules" % type_key) + continue + var value: Variant = (types as Dictionary)[type_name] + if typeof(value) != TYPE_DICTIONARY: + _errors.append("level rules for '%s' must be an object" % type_key) + continue + _parse_type(TYPE_BY_NAME[type_key], value as Dictionary) + + +func _parse_thresholds(raw: Variant) -> void: + if typeof(raw) != TYPE_ARRAY: + _errors.append("level-rules 'levels' must be an array") + return + for entry: Variant in raw: + if typeof(entry) != TYPE_DICTIONARY: + _errors.append("level threshold must be an object") + continue + var level := int((entry as Dictionary).get("level", 0)) + var min_features := int((entry as Dictionary).get("min_features", 0)) + if level < 1 or level > MAX_LEVEL: + _errors.append("level threshold %d is out of range" % level) + continue + if min_features < 0: + _errors.append("level threshold %d has a negative minimum" % level) + continue + _thresholds.append({"level": level, "min_features": min_features}) + _thresholds.sort_custom( + func(a: Dictionary, b: Dictionary) -> bool: + return int(a["level"]) < int(b["level"]) + ) + + +func _parse_fixed_levels(raw: Variant) -> void: + if typeof(raw) != TYPE_DICTIONARY: + _errors.append("level-rules 'fixed_levels' must be an object") + return + for code: Variant in raw as Dictionary: + var level := int((raw as Dictionary)[code]) + if level < 0 or level > MAX_LEVEL: + _errors.append("fixed level for '%s' is out of range" % str(code)) + continue + _fixed_levels[_normalize(str(code))] = level + + +func _parse_type(type: PathSegment.ElementType, data: Dictionary) -> void: + var required: Variant = data.get("required_features", []) + var level4: Variant = data.get("level4_requires_any", []) + var features: Variant = data.get("features", []) + + if typeof(required) == TYPE_ARRAY: + _required_by_type[type] = _to_string_array(required as Array) + if typeof(level4) == TYPE_ARRAY: + _level4_by_type[type] = _to_string_array(level4 as Array) + if typeof(features) != TYPE_ARRAY: + _errors.append("'features' must be an array") + return + + var definitions: Array[ElementFeature] = [] + var by_code: Dictionary = {} + for entry: Variant in features: + if typeof(entry) != TYPE_DICTIONARY: + _errors.append("feature entry must be an object") + continue + var feature := _parse_feature(entry as Dictionary) + if feature == null: + continue + if by_code.has(_normalize(feature.code)): + _errors.append("duplicate feature code '%s'" % feature.code) + continue + by_code[_normalize(feature.code)] = feature + definitions.append(feature) + + _features_by_type[type] = definitions + _features_by_code[type] = by_code + + for required_code: String in _required_by_type.get(type, PackedStringArray()): + if not by_code.has(_normalize(required_code)): + _errors.append("required feature '%s' is not defined" % required_code) + for level4_code: String in _level4_by_type.get(type, PackedStringArray()): + if not by_code.has(_normalize(level4_code)): + _errors.append("level-4 feature '%s' is not defined" % level4_code) + + +func _parse_feature(entry: Dictionary) -> ElementFeature: + var feature := ElementFeature.new() + feature.code = str(entry.get("code", "")).strip_edges() + feature.display_name = str(entry.get("name", "")).strip_edges() + feature.description = str(entry.get("description", "")).strip_edges() + feature.max_per_element = int(entry.get("max_per_element", 1)) + feature.once_per_program = bool(entry.get("once_per_program", true)) + + for message: String in feature.validate(): + _errors.append("%s: %s" % [feature.code, message]) + return feature + + +func _level_for_count(count: int) -> int: + var level := 0 + for entry: Dictionary in _thresholds: + if count >= int(entry["min_features"]): + level = int(entry["level"]) + return level + + +static func _contains_any(counts: Dictionary, codes: PackedStringArray) -> bool: + for code: String in codes: + if counts.has(_normalize(code)): + return true + return false + + +static func _append_unique(target: PackedStringArray, value: String) -> void: + if not target.has(value): + target.append(value) + + +static func _to_string_array(values: Array) -> PackedStringArray: + var result := PackedStringArray() + for value: Variant in values: + var cleaned := str(value).strip_edges() + if not cleaned.is_empty(): + result.append(cleaned) + return result + + +static func _normalize(code: String) -> String: + return code.strip_edges().to_lower() diff --git a/rinkplanner/src/core/rules/element_level_rules.gd.uid b/rinkplanner/src/core/rules/element_level_rules.gd.uid new file mode 100644 index 0000000..d5c53b0 --- /dev/null +++ b/rinkplanner/src/core/rules/element_level_rules.gd.uid @@ -0,0 +1 @@ +uid://x15ykkpkd7kd diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index 2fc3e14..6cf0380 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -50,6 +50,8 @@ 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 ELEMENT_LEVEL_RULES_SCRIPT := preload("res://src/core/rules/element_level_rules.gd") +const FEATURE_MENU_RESET_ID := 1000000 const EXPORT_IMAGE_SIZE := Vector2i(2560, 1600) const AUTOSAVE_PATH := "user://autosave.tres" const SYNC_SETTINGS_PATH := "user://sync.cfg" @@ -111,6 +113,9 @@ const COMPACT_LAYOUT_WIDTH := 1280.0 @onready var element_code_edit: LineEdit = %ElementCodeEdit @onready var element_level_option: OptionButton = %ElementLevelOption @onready var element_value_label: Label = %ElementValueLabel +@onready var element_features_button: Button = %ElementFeaturesButton +@onready var element_feature_hint: Label = %ElementFeatureHint +@onready var element_feature_menu: PopupMenu = %ElementFeatureMenu @onready var element_duration_spin: SpinBox = %ElementDurationSpin @onready var segment_label_dialog: ConfirmationDialog = %SegmentLabelDialog @onready var segment_label_edit: LineEdit = %SegmentLabelEdit @@ -152,6 +157,7 @@ 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 _level_rules: ElementLevelRules var _preset_speed: float = DEFAULT_SPEED_MPS var _current_path: String = "" var _dirty: bool = false @@ -182,6 +188,11 @@ func _ready() -> void: push_warning( "Element catalog: %s" % ", ".join(_element_catalog.get_errors()) ) + _level_rules = ELEMENT_LEVEL_RULES_SCRIPT.load_default() + if not _level_rules.get_errors().is_empty(): + push_warning( + "Level rules: %s" % ", ".join(_level_rules.get_errors()) + ) _setup_tool_options() _setup_file_menu() _setup_playback_controls() @@ -408,6 +419,173 @@ func get_element_catalog() -> ElementCatalog: return _element_catalog +func get_level_rules() -> ElementLevelRules: + return _level_rules + + +func get_selected_element_features() -> PackedStringArray: + var segment := get_selected_segment() + if segment == null: + return PackedStringArray() + return segment.element_features.duplicate() + + +## Replaces the feature selection of the selected element. Returns true when +## the model changed. Features are stored as codes; duplicates are kept for +## features that count more than once (e.g. difficult variations). +func set_selected_element_features(features: PackedStringArray) -> bool: + var segment := get_selected_segment() + if segment == null or not segment.is_element(): + return false + + var cleaned := _clean_feature_codes(features) + if segment.element_features == cleaned: + return false + + _record_undo() + segment.set_element_features(cleaned) + _mark_dirty() + rink_canvas.refresh() + _update_status() + update_element_feature_hint() + return true + + +## Shows the feature count and the derived level in the element inspector. +## The authored level stays untouched; a mismatch is shown explicitly. +func update_element_feature_hint() -> void: + if element_feature_hint == null or element_features_button == null: + return + + element_features_button.text = "Features (0)" + element_features_button.disabled = true + var segment := get_selected_segment() + if segment == null or not segment.is_element(): + element_feature_hint.text = "Kein Element ausgewählt." + return + if segment.element_type == PathSegment.ElementType.JUMP: + element_feature_hint.text = "Sprünge haben keine Level-Features." + return + if _level_rules == null: + element_feature_hint.text = "" + return + + var code := segment.element_code.strip_edges() + if code.is_empty(): + element_feature_hint.text = "Kürzel wählen, um Level-Features zu erfassen." + return + if _element_catalog == null or not _element_catalog.has_code(code): + element_feature_hint.text = "Kürzel nicht im Katalog." + return + + var result := _level_rules.calculate_level( + segment.element_type, + code, + segment.element_features + ) + element_features_button.disabled = false + element_features_button.text = "Features (%d)" % result.counted_features + + if not result.missing_required.is_empty(): + element_feature_hint.text = ( + "Pflichtfeature fehlt: %s" % ", ".join(result.missing_required) + ) + return + + var computed := ElementDefinition.level_label(result.level) + var chosen := ElementDefinition.level_label(segment.element_level) + var suffix := "" if computed == chosen else " · gewählt: %s" % chosen + if not result.ignored_features.is_empty(): + suffix += " · %d ignoriert" % result.ignored_features.size() + element_feature_hint.text = ( + "Features: %d · %s%s" % [result.counted_features, computed, suffix] + ) + + +func _clean_feature_codes(features: PackedStringArray) -> PackedStringArray: + var cleaned := PackedStringArray() + for raw: String in features: + var code := raw.strip_edges() + if code.is_empty(): + continue + cleaned.append(code) + if cleaned.size() >= PathSegment.ELEMENT_MAX_FEATURES: + break + return cleaned + + +func _open_feature_menu() -> void: + if not _populate_feature_menu(): + return + var origin := Vector2i(element_features_button.get_screen_position()) + element_feature_menu.popup( + Rect2i(origin, Vector2i(element_features_button.size)) + ) + + +## Fills the feature menu from the selected element. Split from the popup call +## so tests can inspect the items without opening a window. +func _populate_feature_menu() -> bool: + var segment := get_selected_segment() + if segment == null or _level_rules == null: + return false + var features := _level_rules.get_features(segment.element_type) + if features.is_empty(): + return false + + var counts: Dictionary[String, int] = {} + for code: String in segment.element_features: + var key := code.strip_edges() + if not key.is_empty(): + counts[key] = counts.get(key, 0) + 1 + + element_feature_menu.clear() + for feature: ElementFeature in features: + var selected_count: int = counts.get(feature.code, 0) + for index: int in range(feature.max_per_element): + var label := feature.display_name + if feature.max_per_element > 1: + label += " (%d/%d)" % [index + 1, feature.max_per_element] + var item_id := element_feature_menu.item_count + element_feature_menu.add_check_item(label, item_id) + element_feature_menu.set_item_metadata(item_id, feature.code) + element_feature_menu.set_item_checked(item_id, index < selected_count) + element_feature_menu.set_item_tooltip(item_id, feature.description) + + element_feature_menu.add_separator() + element_feature_menu.add_item("Auswahl zurücksetzen", FEATURE_MENU_RESET_ID) + return true + + +## Checkable PopupMenu items do not toggle themselves; only the explicit reset +## entry is special. +func _on_feature_menu_id_pressed(id: int) -> void: + if id == FEATURE_MENU_RESET_ID: + for index: int in range(element_feature_menu.item_count): + if element_feature_menu.is_item_checkable(index): + element_feature_menu.set_item_checked(index, false) + return + if id < 0 or id >= element_feature_menu.item_count: + return + if not element_feature_menu.is_item_checkable(id): + return + element_feature_menu.set_item_checked( + id, + not element_feature_menu.is_item_checked(id) + ) + + +func _on_feature_menu_hidden() -> void: + var features := PackedStringArray() + for index: int in range(element_feature_menu.item_count): + if ( + element_feature_menu.is_item_checkable(index) + and element_feature_menu.is_item_checked(index) + ): + features.append(str(element_feature_menu.get_item_metadata(index))) + set_selected_element_features(features) + + ## 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: @@ -537,6 +715,7 @@ func set_selected_element( rink_canvas.refresh() _sync_toolbar_to_selection() _update_status() + update_element_feature_hint() return true @@ -615,6 +794,11 @@ func _setup_element_controls() -> void: element_dialog_type_option.item_selected.connect( _on_element_value_option_selected ) + element_features_button.pressed.connect(_open_feature_menu) + element_feature_menu.hide_on_item_selection = false + element_feature_menu.hide_on_checkable_item_selection = false + element_feature_menu.id_pressed.connect(_on_feature_menu_id_pressed) + element_feature_menu.popup_hide.connect(_on_feature_menu_hidden) func _on_element_code_text_changed(_text: String) -> void: @@ -667,6 +851,7 @@ func _open_element_dialog() -> void: element_code_edit.grab_focus() element_code_edit.select_all() update_element_value_hint() + update_element_feature_hint() func _on_element_confirmed() -> void: @@ -791,6 +976,7 @@ func select_segment(segment_id: String) -> void: rink_canvas.set_selected_segment(segment_id) _sync_toolbar_to_selection() _update_status() + update_element_feature_hint() ## Selects a tool programmatically and keeps the toolbar in sync. @@ -937,6 +1123,7 @@ func _clone_segment(source: PathSegment) -> PathSegment: clone.element_type = source.element_type clone.element_code = source.element_code clone.element_level = source.element_level + clone.element_features = source.element_features.duplicate() clone.element_duration_seconds = source.element_duration_seconds clone.label = source.label clone.template = source.template diff --git a/rinkplanner/tests/README.md b/rinkplanner/tests/README.md index 381d972..4a6a203 100644 --- a/rinkplanner/tests/README.md +++ b/rinkplanner/tests/README.md @@ -24,6 +24,9 @@ $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 ISU level-feature tests +$GODOT --headless --path rinkplanner --script res://tests/run_level_tests.gd + # Run canvas transform/geometry tests $GODOT --headless --path rinkplanner --script res://tests/run_canvas_tests.gd diff --git a/rinkplanner/tests/manual/capture_elements.gd b/rinkplanner/tests/manual/capture_elements.gd index 40bb5ee..4e34e3a 100644 --- a/rinkplanner/tests/manual/capture_elements.gd +++ b/rinkplanner/tests/manual/capture_elements.gd @@ -51,7 +51,7 @@ func _capture() -> void: "3Lz", 0 ) - controller.add_element_marker( + var spin := controller.add_element_marker( Vector2(-4.0, 9.0), PathSegment.ElementType.SPIN, "CCoSp4", @@ -83,6 +83,12 @@ func _capture() -> void: controller.set_tool(WhiteboardController.Tool.ELEMENT) elif args.size() > 3 and args[3] == "dialog": controller.element_button.pressed.emit() + elif args.size() > 3 and args[3] == "features": + controller.select_segment(spin.segment_id) + controller.set_selected_element_features( + PackedStringArray(["difficult_variation", "difficult_exit"]) + ) + controller.element_button.pressed.emit() elif args.size() > 3 and args[3] == "spin": var elapsed := 0.0 for segment: PathSegment in controller.get_active_section().segments: diff --git a/rinkplanner/tests/run_level_tests.gd b/rinkplanner/tests/run_level_tests.gd new file mode 100644 index 0000000..e34d205 --- /dev/null +++ b/rinkplanner/tests/run_level_tests.gd @@ -0,0 +1,360 @@ +extends SceneTree + +## Headless tests for the ISU level rules and feature selection. +## +## Run with: +## godot --headless --path rinkplanner --script res://tests/run_level_tests.gd + +const ElementLevelRulesScript := preload("res://src/core/rules/element_level_rules.gd") +const PathSegmentModel := preload("res://src/core/model/path_segment.gd") + +var _assertions: int = 0 +var _failures: PackedStringArray = PackedStringArray() +var _rules: ElementLevelRules + + +func _init() -> void: + _rules = ElementLevelRulesScript.load_default() + + _test_rules_metadata() + _test_spin_levels() + _test_sequence_levels() + _test_fixed_and_unlevelled_elements() + _test_feature_validation() + _test_segment_features() + _finish() + + +func _test_rules_metadata() -> void: + _check(_rules != null, "level rules load") + _check( + _rules.get_errors().is_empty(), + "level rules parse without errors (%s)" % ", ".join(_rules.get_errors()) + ) + _check(_rules.is_valid(), "level rules are valid") + _check(_rules.season == "2025/26", "level rules season is 2025/26") + _check(_rules.source.contains("2701"), "level rules name ISU communication 2701") + _check(_rules.valid_from == "2025-07-01", "level rules valid from 2025-07-01") + _check( + _rules.get_features(PathSegment.ElementType.SPIN).size() == 14, + "spin rules contain 14 features" + ) + _check( + _rules.get_features(PathSegment.ElementType.SEQUENCE).size() == 4, + "sequence rules contain 4 features" + ) + _check( + _rules.get_features(PathSegment.ElementType.JUMP).is_empty(), + "jumps have no level features" + ) + + var variation: ElementFeature = _rules.get_feature( + PathSegment.ElementType.SPIN, + "difficult_variation" + ) + _check(variation != null, "difficult variation exists") + _check(variation.max_per_element == 2, "difficult variation counts twice") + _check(not variation.once_per_program, "difficult variation is not once-only") + var exit: ElementFeature = _rules.get_feature( + PathSegment.ElementType.SPIN, + "difficult_exit" + ) + _check(exit != null and exit.once_per_program, "difficult exit counts once") + + +func _test_spin_levels() -> void: + var spins := PathSegment.ElementType.SPIN + var none := PackedStringArray() + _check_level(spins, "CCoSp", none, 0, "a spin without features is Base") + _check_level( + spins, + "CCoSp", + PackedStringArray(["difficult_variation"]), + 1, + "one feature gives Level 1" + ) + _check_level( + spins, + "CCoSp", + PackedStringArray(["difficult_variation", "difficult_variation"]), + 2, + "two difficult variations give Level 2" + ) + _check_level( + spins, + "CCoSp", + PackedStringArray( + ["difficult_variation", "difficult_variation", "difficult_variation"] + ), + 2, + "a third difficult variation is ignored" + ) + _check_level( + spins, + "CCoSp", + PackedStringArray( + [ + "difficult_variation", + "difficult_variation", + "difficult_exit", + "change_of_edge", + ] + ), + 4, + "four features including a level-4 feature give Level 4" + ) + _check_level( + spins, + "CCoSp", + PackedStringArray( + [ + "difficult_variation", + "difficult_variation", + "change_foot_jump", + "jump_in_spin", + ] + ), + 3, + "four features without a level-4 feature stop at Level 3" + ) + + var result := _rules.calculate_level( + spins, + "CCoSp", + PackedStringArray(["unknown_feature", "difficult_exit"]) + ) + _check(result.ignored_features.has("unknown_feature"), "unknown features are ignored") + _check(result.counted_features == 1, "only known features count") + + +func _test_sequence_levels() -> void: + var sequences := PathSegment.ElementType.SEQUENCE + _check_level(sequences, "StSq", PackedStringArray(), 0, "a step sequence without features is Base") + _check_level( + sequences, + "StSq", + PackedStringArray(["both_rotations"]), + 0, + "a step sequence without the compulsory feature stays Base" + ) + _check_level( + sequences, + "StSq", + PackedStringArray(["variety_of_turns"]), + 1, + "the compulsory feature alone gives Level 1" + ) + _check_level( + sequences, + "StSq", + PackedStringArray(["variety_of_turns", "both_rotations"]), + 2, + "two step-sequence features give Level 2" + ) + _check_level( + sequences, + "StSq", + PackedStringArray( + [ + "variety_of_turns", + "both_rotations", + "body_movements", + "turn_combinations", + ] + ), + 4, + "all four step-sequence features give Level 4" + ) + + var missing := _rules.calculate_level( + sequences, + "StSq", + PackedStringArray(["both_rotations"]) + ) + _check( + missing.missing_required.has("variety_of_turns"), + "missing compulsory feature is reported" + ) + + +func _test_fixed_and_unlevelled_elements() -> void: + var chsq := _rules.calculate_level( + PathSegment.ElementType.SEQUENCE, + "ChSq", + PackedStringArray() + ) + _check(chsq.level == 1, "ChSq is fixed at Level 1") + var chsq_with_features := _rules.calculate_level( + PathSegment.ElementType.SEQUENCE, + "ChSq1", + PackedStringArray(["variety_of_turns"]) + ) + _check(chsq_with_features.level == 1, "ChSq ignores feature selections") + _check( + _rules.calculate_level( + PathSegment.ElementType.JUMP, + "ChSq", + PackedStringArray() + ).level == 0, + "a fixed level only applies to the matching element type" + ) + + var jump := _rules.calculate_level( + PathSegment.ElementType.JUMP, + "3Lz", + PackedStringArray(["difficult_exit"]) + ) + _check(jump.level == 0, "jumps have no level") + _check( + jump.ignored_features.has("difficult_exit"), + "features on jumps are ignored" + ) + + +func _test_feature_validation() -> void: + var spins := PathSegment.ElementType.SPIN + _check( + _rules.validate_selection( + spins, + PackedStringArray(["difficult_variation", "difficult_exit"]) + ).is_empty(), + "a valid spin selection has no errors" + ) + _check( + _contains_error( + _rules.validate_selection(spins, PackedStringArray(["unknown"])), + "unknown feature" + ), + "unknown features are reported" + ) + _check( + _contains_error( + _rules.validate_selection( + spins, + PackedStringArray( + ["difficult_variation", "difficult_variation", "difficult_variation"] + ) + ), + "more than 2 time(s)" + ), + "over-limit repetitions are reported" + ) + _check( + _contains_error( + _rules.validate_selection( + PathSegment.ElementType.SEQUENCE, + PackedStringArray(["body_movements"]) + ), + "required feature" + ), + "missing compulsory sequence features are reported" + ) + _check( + _rules.get_required_features(PathSegment.ElementType.SEQUENCE) + == PackedStringArray(["variety_of_turns"]), + "required sequence features are exposed" + ) + _check( + _rules.get_level4_features(spins).size() == 6, + "six spin features unlock Level 4" + ) + + +func _test_segment_features() -> void: + var marker: PathSegment = PathSegmentModel.new() + marker.segment_id = "spin" + marker.curve = _make_point_curve(Vector2.ZERO) + marker.set_element(PathSegment.ElementType.SPIN, "CCoSp", 4) + marker.set_element_features( + PackedStringArray(["difficult_variation", "difficult_variation", "difficult_exit"]) + ) + _check(marker.element_features.size() == 3, "features are stored on the segment") + _check(marker.is_valid(), "a segment with features is valid") + + var result := _rules.calculate_level( + marker.element_type, + marker.element_code, + marker.element_features + ) + _check(result.level == 3, "segment features produce a level") + _check(result.counted_features == 3, "segment features are counted") + + marker.set_element_features( + PackedStringArray([" difficult_exit ", "", "change_of_edge"]) + ) + _check( + marker.element_features == PackedStringArray(["difficult_exit", "change_of_edge"]), + "feature codes are trimmed and empty entries dropped" + ) + + var many := PackedStringArray() + for index: int in range(30): + many.append("feature_%d" % index) + marker.set_element_features(many) + _check( + marker.element_features.size() == PathSegment.ELEMENT_MAX_FEATURES, + "feature selection is capped" + ) + + marker.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 2) + _check( + marker.element_features.is_empty(), + "changing the element type clears features" + ) + marker.set_element_features(PackedStringArray(["variety_of_turns"])) + marker.set_element(PathSegment.ElementType.NONE, "", 0) + _check( + marker.element_features.is_empty(), + "removing the element clears features" + ) + + var untagged: PathSegment = PathSegmentModel.new() + untagged.segment_id = "untagged" + untagged.curve = _make_point_curve(Vector2.ZERO) + untagged.set_element_features(PackedStringArray(["difficult_exit"])) + _check( + untagged.element_features.is_empty(), + "features without an element type are dropped" + ) + + +func _check_level( + type: PathSegment.ElementType, + code: String, + features: PackedStringArray, + expected: int, + message: String +) -> void: + var result := _rules.calculate_level(type, code, features) + _check(result.level == expected, "%s (got %d)" % [message, result.level]) + + +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 _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_level_tests.gd.uid b/rinkplanner/tests/run_level_tests.gd.uid new file mode 100644 index 0000000..94aef0b --- /dev/null +++ b/rinkplanner/tests/run_level_tests.gd.uid @@ -0,0 +1 @@ +uid://c3c5ba87ey8vl diff --git a/rinkplanner/tests/run_whiteboard_tests.gd b/rinkplanner/tests/run_whiteboard_tests.gd index 0635f21..706fae7 100644 --- a/rinkplanner/tests/run_whiteboard_tests.gd +++ b/rinkplanner/tests/run_whiteboard_tests.gd @@ -794,6 +794,87 @@ func _run() -> void: "unknown codes are marked as not in the catalog" ) + # Level features and the derived level. + _check( + controller.set_selected_element_features( + PackedStringArray(["difficult_variation", "difficult_exit"]) + ), + "features can be assigned to an element" + ) + _check( + controller.get_selected_element_features().size() == 2, + "features are stored on the selected segment" + ) + _check( + controller.element_feature_hint.text.contains("Features: 2") + and controller.element_feature_hint.text.contains("Level 2") + and controller.element_feature_hint.text.contains("gewählt: Level 4"), + "feature hint shows the derived level and the mismatch" + ) + _check( + not controller.element_features_button.disabled, + "feature button is enabled for a spin" + ) + _check( + controller._populate_feature_menu(), + "feature menu populates for a spin" + ) + _check( + controller.element_feature_menu.item_count == 17, + "feature menu lists 14 features plus the second difficult variation" + ) + _check( + controller.element_feature_menu.get_item_metadata(0) == "difficult_variation", + "feature menu items carry their feature code" + ) + _check( + controller.element_feature_menu.is_item_checked(0), + "the selected difficult variation is checked" + ) + _check( + controller.element_feature_menu.is_item_checked(6), + "the selected difficult exit is checked" + ) + controller.element_feature_menu.set_item_checked(1, false) + controller._on_feature_menu_id_pressed(1) + _check( + controller.element_feature_menu.is_item_checked(1), + "clicking a feature toggles its check state" + ) + controller._on_feature_menu_hidden() + _check( + controller.get_selected_element_features().size() == 3, + "a second difficult variation can be added" + ) + _check( + controller.element_feature_hint.text.contains("Features: 3"), + "feature hint follows the selection" + ) + _check(controller.undo(), "feature selection can be undone") + spin = controller.get_active_section().get_segment_by_id(spin.segment_id) + _check(spin != null, "the spin survives undo") + controller.select_segment(spin.segment_id) + _check( + controller.get_selected_element_features().size() == 2, + "undo restores the previous feature selection" + ) + _check(controller.redo(), "feature selection can be redone") + spin = controller.get_active_section().get_segment_by_id(spin.segment_id) + _check(spin != null, "the spin survives redo") + controller.select_segment(spin.segment_id) + _check( + controller.get_selected_element_features().size() == 3, + "redo restores the feature selection" + ) + _check( + controller.set_selected_element_features(PackedStringArray()), + "features can be cleared" + ) + _check( + controller.get_selected_element_features().is_empty(), + "clearing removes all features" + ) + controller.element_code_edit.text = "CCoSp" controller.element_level_option.select( controller.element_level_option.get_item_index(2) diff --git a/tools/test.sh b/tools/test.sh index b543410..3f6a9f6 100755 --- a/tools/test.sh +++ b/tools/test.sh @@ -25,6 +25,9 @@ fi "$GODOT" --headless --path "$PROJECT_DIR" \ --script res://tests/run_rules_tests.gd +"$GODOT" --headless --path "$PROJECT_DIR" \ + --script res://tests/run_level_tests.gd + "$GODOT" --headless --path "$PROJECT_DIR" \ --script res://tests/run_canvas_tests.gd