feat: ISU-Level-Features und Level-Berechnung

- ElementFeature/ElementLevelRules mit Daten aus ISU Communication 2701
- 14 Pirouetten- und 4 Schrittsequenz-Features inkl. Pflicht- und
  Level-4-Regeln
- PathSegment.element_features mit Duplikaten fuer schwierige Variationen
- Feature-Menue und abgeleiteter Level-Hinweis im Element-Inspector,
  Auswahl undo-faehig
- 47 neue Level-Assertions, Whiteboard-Tests auf 228 erweitert (833 gesamt)
- Doku: isu-rules, Findings, Architektur und Roadmap aktualisiert
This commit is contained in:
torsten 2026-10-31 09:21:03 +01:00
parent 789fbc2826
commit 0613ffca3e
18 changed files with 1490 additions and 25 deletions

View file

@ -3,8 +3,8 @@
Stand: 2026-10-31 Stand: 2026-10-31
Grundlage: `rinkplanner/rinkplanner_definition_agent_guidelines.md` Grundlage: `rinkplanner/rinkplanner_definition_agent_guidelines.md`
Übergeordnete Reihenfolge: `docs/roadmap.md` Übergeordnete Reihenfolge: `docs/roadmap.md`
Letzte Session: `docs/findings-2026-10-31-isu-katalog.md` Letzte Session: `docs/findings-2026-10-31-isu-levels.md`
(Session davor: `docs/findings-2026-10-30-element-marker.md`) (Session davor: `docs/findings-2026-10-31-isu-katalog.md`)
## 1. Leitentscheidung ## 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 | | `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 | | `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 ### 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 einen stillen Standardwert. Das JSON wird über `include_filter="*.json"` in die
Exporte aufgenommen. 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 ## 4. View- und Controller-Grenzen
- **View** (`Node2D`/`Control`) liest das Modell und zeichnet. Sie verändert - **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 Inspector übersteuert wird und in die Timeline eingeht. Der Inspector zeigt
außerdem den **Base Value** des eingegebenen Kürzels und Levels aus dem außerdem den **Base Value** des eingegebenen Kürzels und Levels aus dem
Saisonkatalog; unbekannte Kürzel werden als „nicht im Katalog“ markiert. 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 Die Timing-Details (Dauer/Tempo/Profil) werden beim Setzen und für
Punktmarker ausgeblendet, damit die Leiste auch im Landscape kompakt bleibt. Punktmarker ausgeblendet, damit die Leiste auch im Landscape kompakt bleibt.
- **Section-Verwaltung:** Ein Panel rechts zeigt die chronologische - **Section-Verwaltung:** Ein Panel rechts zeigt die chronologische
@ -313,13 +328,17 @@ Aktueller Stand:
- **Regelwerk:** 160 Assertions für Katalog-Metadaten, Saison/Quelle, - **Regelwerk:** 160 Assertions für Katalog-Metadaten, Saison/Quelle,
Sprung-/Pirouetten-/Sequenz-Base-Values, Level-Auflösung, Kürzel-Suffixe, Sprung-/Pirouetten-/Sequenz-Base-Values, Level-Auflösung, Kürzel-Suffixe,
Case-Insensitivität, Vorschläge, Segment-Integration und fehlerhafte Kataloge. 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, - **Canvas:** 90 Assertions für Meter→Pixel-Mapping, Fit/Zoom/Pan,
Rink-Kontur und die reine Bogen-Geometrie. 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 Linien-/Bogenpfade, Klemmen an der Bande, Auswahl, Griff- und
Richtungs-/Kanten-Bearbeitung, Segmentlöschung, Element-Marker (Setzen, Richtungs-/Kanten-Bearbeitung, Segmentlöschung, Element-Marker (Setzen,
Typwechsel, Inspector inkl. Standzeit und Base-Value-Hinweis, Verschieben, Typwechsel, Inspector inkl. Standzeit, Base-Value- und Feature-Hinweis,
Löschen), Section-Verwaltung, Feature-Menü, Verschieben, Löschen), Section-Verwaltung,
Ghosting-Zustand, Segment-Labels inklusive Dialog und Sichtbarkeits-Schalter, Ghosting-Zustand, Segment-Labels inklusive Dialog und Sichtbarkeits-Schalter,
Speichern/Laden, Schema-Prüfung, Dirty-State, Speichern/Laden, Schema-Prüfung, Dirty-State,
Navigationsmodus und den Maus-Drag-Pfad. Navigationsmodus und den Maus-Drag-Pfad.

View file

@ -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.

View file

@ -1,9 +1,15 @@
# ISU-Regelwerk – Elementkatalog # ISU-Regelwerk – Elementkatalog und Level-Features
Stand: 2026-10-31 Stand: 2026-10-31
Saison: **2025/26** Saison: **2025/26**
Quelle: ISU Communication No. 2707, *Single & Pair Skating – Scale of Values
Quellen:
- ISU Communication No. 2707, *Single & Pair Skating – Scale of Values
valid as of July 1, 2025* (ersetzt Communication 2656) 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 ## Zweck
@ -17,20 +23,25 @@ Aktuell abgedeckt:
- **16 Pirouettenfamilien** der Einzel- und Paarlauf-SoV - **16 Pirouettenfamilien** der Einzel- und Paarlauf-SoV
(einpositionig, mit Fußwechsel, Kombinationen, jeweils auch geflogen) (einpositionig, mit Fußwechsel, Kombinationen, jeweils auch geflogen)
- **2 Sequenzen**: `StSq` (Base–4) und `ChSq` (nur Level 1) - **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, Nicht abgedeckt (bewusst offen): GOE-Tabellen, reduzierte `V`-Varianten,
Unterrotations-/Fehlkanten-Suffixe (`<`, `<<`, `q`, `e`, `!`), Sprungkombinationen Unterrotations-/Fehlkanten-Suffixe (`<`, `<<`, `q`, `e`, `!`), Sprungkombinationen
und -folgen, Paarlauf-Hebungen/Twists/Throws, Eistanz-Elemente, Feature-Kriterien und -folgen, Paarlauf-Hebungen/Twists/Throws sowie Eistanz-Elemente.
und die daraus abgeleitete Level-Bestimmung.
## Dateien ## Dateien
| Datei | Inhalt | | 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_catalog.gd` | Laden, Lookup, Vorschläge, Prüfung |
| `rinkplanner/src/core/rules/element_definition.gd` | eine Elementfamilie mit BV je Level | | `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 ## 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 - Der Base Value wird **nicht** am Segment gespeichert. Das Segment trägt nur
`element_code` und `element_level`; die Anzeige fragt den Katalog. `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 ## Bedienung
Der Element-Inspector zeigt unter der Level-Auswahl `Base Value: 3,50`. 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 Hinweis aktualisiert sich bei Änderungen an Typ, Kürzel und Level; der Tooltip
nennt Saison und Quelle. 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 ## Neue Saison einpflegen
1. Neue ISU-Communication (Scale of Values) beschaffen und als JSON nach dem 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. 3. `ElementCatalog.DEFAULT_PATH` auf die neue Datei zeigen lassen.
4. Stichproben in `tests/run_rules_tests.gd` auf die neuen Werte anpassen 4. Stichproben in `tests/run_rules_tests.gd` auf die neuen Werte anpassen
(mindestens ein Sprung, eine Pirouette, eine Sequenz). (mindestens ein Sprung, eine Pirouette, eine Sequenz).
5. `./tools/test.sh` ausführen. 5. Neue Level-Communication (Levels of Difficulty) als
6. Die alte Datei kann für Nachvollziehbarkeit im Repo bleiben; aktiv ist `isu_levels_2026_27.json` anlegen, `ElementLevelRules.DEFAULT_PATH`
immer genau eine Datei. 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. mit ausgeliefert.
## Nächste Ausbaustufen ## 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 - GOE-Tabellen und `V`-/Unterrotations-Varianten
- Sprungkombinationen und -folgen als zusammengesetzte Elemente - Sprungkombinationen und -folgen als zusammengesetzte Elemente
- Programmvalidierung (erlaubte Elementanzahl, Wiederholungen, Adult-Regeln) - Programmvalidierung (erlaubte Elementanzahl, Wiederholungen, Adult-Regeln)

View file

@ -1,6 +1,6 @@
# Rinkplanner – Roadmap # 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 Diese Reihenfolge ist die verbindliche Arbeitsgrundlage für Phase 1. Änderungen
nur bewusst und nach Rücksprache. Erkenntnisse der letzten Session: nur bewusst und nach Rücksprache. Erkenntnisse der letzten Session:
`docs/findings-2026-10-30-element-marker.md`. `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 - [x] Regelversionen pflegbar halten (saisonale JSON-Datei mit Quelle und
Gültigkeitsdatum) Gültigkeitsdatum)
- [x] Base-Value-Hinweis im Element-Inspector - [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 - [ ] Validierung von Elementen und Kombinationen
- [ ] Programmweite Feature-Grenzen (`once_per_program`, max. 2 pro Fuß)
- [ ] Optional: Kürzelvorschläge im Inspector aus `suggest()` - [ ] Optional: Kürzelvorschläge im Inspector aus `suggest()`
- [ ] Optional: GOE-Tabellen sowie `V`-/Unterrotationsvarianten - [ ] Optional: GOE-Tabellen sowie `V`-/Unterrotationsvarianten
@ -143,11 +146,11 @@ fachlichen Validierung angefasst.
Übernahme des Feedbacks der Tester Übernahme des Feedbacks der Tester
Die Reihenfolge ist bewusst: native Builds, Datenaustausch und Element-Marker Die Reihenfolge ist bewusst: native Builds, Datenaustausch und Element-Marker
sind erledigt. Im PoC läuft jetzt das ISU-Regelwerk – der Katalog steht, als sind erledigt. Im PoC läuft jetzt das ISU-Regelwerk – Katalog und
Nächstes folgen Features und Validierung. Sync-Komfort und UI-Refactoring sind Level-Features stehen, als Nächstes folgt die Validierung. Sync-Komfort und
zurückgestellt, weil der bestehende Stand für Tests genügt und die endgültige UI-Refactoring sind zurückgestellt, weil der bestehende Stand für Tests genügt
Sync-Architektur (PHP-Webserver) sowie das UI-Feedback der Tester ohnehin noch und die endgültige Sync-Architektur (PHP-Webserver) sowie das UI-Feedback der
ausstehen. Tester ohnehin noch ausstehen.
## Querschnittsaufgaben ## Querschnittsaufgaben

View file

@ -622,6 +622,23 @@ theme_override_colors/font_color = Color(0.74902, 0.803922, 0.878431, 1)
theme_override_font_sizes/font_size = 15 theme_override_font_sizes/font_size = 15
text = "Base Value: –" 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"] [node name="ElementDurationLabel" type="Label" parent="ElementDialog/ElementBox"]
layout_mode = 2 layout_mode = 2
theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) 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_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1)
theme_override_font_sizes/font_size = 12 theme_override_font_sizes/font_size = 12
text = "Ziel: user://exports" 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

View file

@ -39,6 +39,7 @@ enum ElementType {
const ELEMENT_CODE_MAX_LENGTH := 24 const ELEMENT_CODE_MAX_LENGTH := 24
const ELEMENT_MAX_LEVEL := 4 const ELEMENT_MAX_LEVEL := 4
const ELEMENT_MAX_DURATION_SECONDS := 120.0 const ELEMENT_MAX_DURATION_SECONDS := 120.0
const ELEMENT_MAX_FEATURES := 16
@export var segment_id: String = "" @export var segment_id: String = ""
@export var curve: Curve2D @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 ## ISU level: 0 is "Base", 1–4 are the graded levels. Only used by spins and
## sequences; jumps keep 0. ## sequences; jumps keep 0.
@export var element_level: int = 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 ## 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. ## independent of the geometry; ranges use [member duration_seconds] instead.
@export var element_duration_seconds: float = 0.0 @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. ## 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: func set_element(type: ElementType, code: String, level: int) -> void:
var previous_type := element_type
element_type = type element_type = type
if type == ElementType.NONE: if type == ElementType.NONE:
element_code = "" element_code = ""
element_level = 0 element_level = 0
element_features = PackedStringArray()
return return
if type != previous_type:
element_features = PackedStringArray()
element_code = code.strip_edges().left(ELEMENT_CODE_MAX_LENGTH) element_code = code.strip_edges().left(ELEMENT_CODE_MAX_LENGTH)
element_level = clampi(level, 0, ELEMENT_MAX_LEVEL) 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". ## Short caption for the canvas and exports, e.g. "3Lz" or "CCoSp4 L3".
func get_element_caption() -> String: func get_element_caption() -> String:
var code := element_code.strip_edges() 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(): if element_type == ElementType.NONE and not element_code.strip_edges().is_empty():
errors.append("element_code needs an element_type") 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 ( if (
element_duration_seconds < 0.0 element_duration_seconds < 0.0
or element_duration_seconds > ELEMENT_MAX_DURATION_SECONDS or element_duration_seconds > ELEMENT_MAX_DURATION_SECONDS

View file

@ -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
}
]
}
}
}

View file

@ -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()

View file

@ -0,0 +1 @@
uid://dt4yhcekedj6j

View file

@ -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()

View file

@ -0,0 +1 @@
uid://x15ykkpkd7kd

View file

@ -50,6 +50,8 @@ const ROUTINES_DIR := "user://routines"
const EXPORTS_DIR := "user://exports" const EXPORTS_DIR := "user://exports"
const EXPORT_SHEET_SCENE := preload("res://scenes/export/export_sheet.tscn") 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_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 EXPORT_IMAGE_SIZE := Vector2i(2560, 1600)
const AUTOSAVE_PATH := "user://autosave.tres" const AUTOSAVE_PATH := "user://autosave.tres"
const SYNC_SETTINGS_PATH := "user://sync.cfg" 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_code_edit: LineEdit = %ElementCodeEdit
@onready var element_level_option: OptionButton = %ElementLevelOption @onready var element_level_option: OptionButton = %ElementLevelOption
@onready var element_value_label: Label = %ElementValueLabel @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 element_duration_spin: SpinBox = %ElementDurationSpin
@onready var segment_label_dialog: ConfirmationDialog = %SegmentLabelDialog @onready var segment_label_dialog: ConfirmationDialog = %SegmentLabelDialog
@onready var segment_label_edit: LineEdit = %SegmentLabelEdit @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_type: PathSegment.ElementType = PathSegment.ElementType.JUMP
var _element_level: int = 0 var _element_level: int = 0
var _element_catalog: ElementCatalog var _element_catalog: ElementCatalog
var _level_rules: ElementLevelRules
var _preset_speed: float = DEFAULT_SPEED_MPS var _preset_speed: float = DEFAULT_SPEED_MPS
var _current_path: String = "" var _current_path: String = ""
var _dirty: bool = false var _dirty: bool = false
@ -182,6 +188,11 @@ func _ready() -> void:
push_warning( push_warning(
"Element catalog: %s" % ", ".join(_element_catalog.get_errors()) "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_tool_options()
_setup_file_menu() _setup_file_menu()
_setup_playback_controls() _setup_playback_controls()
@ -408,6 +419,173 @@ func get_element_catalog() -> ElementCatalog:
return _element_catalog 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 ## Updates the Base-Value hint in the element inspector. Public so tests and
## callers that set the controls programmatically can refresh it explicitly. ## callers that set the controls programmatically can refresh it explicitly.
func update_element_value_hint() -> void: func update_element_value_hint() -> void:
@ -537,6 +715,7 @@ func set_selected_element(
rink_canvas.refresh() rink_canvas.refresh()
_sync_toolbar_to_selection() _sync_toolbar_to_selection()
_update_status() _update_status()
update_element_feature_hint()
return true return true
@ -615,6 +794,11 @@ func _setup_element_controls() -> void:
element_dialog_type_option.item_selected.connect( element_dialog_type_option.item_selected.connect(
_on_element_value_option_selected _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: 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.grab_focus()
element_code_edit.select_all() element_code_edit.select_all()
update_element_value_hint() update_element_value_hint()
update_element_feature_hint()
func _on_element_confirmed() -> void: func _on_element_confirmed() -> void:
@ -791,6 +976,7 @@ func select_segment(segment_id: String) -> void:
rink_canvas.set_selected_segment(segment_id) rink_canvas.set_selected_segment(segment_id)
_sync_toolbar_to_selection() _sync_toolbar_to_selection()
_update_status() _update_status()
update_element_feature_hint()
## Selects a tool programmatically and keeps the toolbar in sync. ## 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_type = source.element_type
clone.element_code = source.element_code clone.element_code = source.element_code
clone.element_level = source.element_level clone.element_level = source.element_level
clone.element_features = source.element_features.duplicate()
clone.element_duration_seconds = source.element_duration_seconds clone.element_duration_seconds = source.element_duration_seconds
clone.label = source.label clone.label = source.label
clone.template = source.template clone.template = source.template

View file

@ -24,6 +24,9 @@ $GODOT --headless --path rinkplanner --script res://tests/run_model_tests.gd
# Run ISU element catalog tests # Run ISU element catalog tests
$GODOT --headless --path rinkplanner --script res://tests/run_rules_tests.gd $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 # Run canvas transform/geometry tests
$GODOT --headless --path rinkplanner --script res://tests/run_canvas_tests.gd $GODOT --headless --path rinkplanner --script res://tests/run_canvas_tests.gd

View file

@ -51,7 +51,7 @@ func _capture() -> void:
"3Lz", "3Lz",
0 0
) )
controller.add_element_marker( var spin := controller.add_element_marker(
Vector2(-4.0, 9.0), Vector2(-4.0, 9.0),
PathSegment.ElementType.SPIN, PathSegment.ElementType.SPIN,
"CCoSp4", "CCoSp4",
@ -83,6 +83,12 @@ func _capture() -> void:
controller.set_tool(WhiteboardController.Tool.ELEMENT) controller.set_tool(WhiteboardController.Tool.ELEMENT)
elif args.size() > 3 and args[3] == "dialog": elif args.size() > 3 and args[3] == "dialog":
controller.element_button.pressed.emit() 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": elif args.size() > 3 and args[3] == "spin":
var elapsed := 0.0 var elapsed := 0.0
for segment: PathSegment in controller.get_active_section().segments: for segment: PathSegment in controller.get_active_section().segments:

View file

@ -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)

View file

@ -0,0 +1 @@
uid://c3c5ba87ey8vl

View file

@ -794,6 +794,87 @@ func _run() -> void:
"unknown codes are marked as not in the catalog" "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_code_edit.text = "CCoSp"
controller.element_level_option.select( controller.element_level_option.select(
controller.element_level_option.get_item_index(2) controller.element_level_option.get_item_index(2)

View file

@ -25,6 +25,9 @@ fi
"$GODOT" --headless --path "$PROJECT_DIR" \ "$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/run_rules_tests.gd --script res://tests/run_rules_tests.gd
"$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/run_level_tests.gd
"$GODOT" --headless --path "$PROJECT_DIR" \ "$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/run_canvas_tests.gd --script res://tests/run_canvas_tests.gd