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:
parent
789fbc2826
commit
0613ffca3e
18 changed files with 1490 additions and 25 deletions
|
|
@ -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.
|
||||
|
|
|
|||
105
docs/findings-2026-10-31-isu-levels.md
Normal file
105
docs/findings-2026-10-31-isu-levels.md
Normal 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.
|
||||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
163
rinkplanner/src/core/rules/data/isu_levels_2025_26.json
Normal file
163
rinkplanner/src/core/rules/data/isu_levels_2025_26.json
Normal 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
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
}
|
||||
34
rinkplanner/src/core/rules/element_feature.gd
Normal file
34
rinkplanner/src/core/rules/element_feature.gd
Normal 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()
|
||||
1
rinkplanner/src/core/rules/element_feature.gd.uid
Normal file
1
rinkplanner/src/core/rules/element_feature.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://dt4yhcekedj6j
|
||||
376
rinkplanner/src/core/rules/element_level_rules.gd
Normal file
376
rinkplanner/src/core/rules/element_level_rules.gd
Normal 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()
|
||||
1
rinkplanner/src/core/rules/element_level_rules.gd.uid
Normal file
1
rinkplanner/src/core/rules/element_level_rules.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://x15ykkpkd7kd
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
360
rinkplanner/tests/run_level_tests.gd
Normal file
360
rinkplanner/tests/run_level_tests.gd
Normal 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)
|
||||
1
rinkplanner/tests/run_level_tests.gd.uid
Normal file
1
rinkplanner/tests/run_level_tests.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://c3c5ba87ey8vl
|
||||
|
|
@ -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)
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue