feat: ISU 2026/27 und Adult-Kategorien

- SoV 2026/27 (Communication 2786) und Levels 2026/27 (2788)
- 15 Pirouetten- und 5 Sequenz-Features, Windmills, neues ChSp1
- Adult-Kategorien Gold/Silver/Bronze plus Masters/Elite aus dem
  IAFSC-Announcement 2026/27
- Kategorie-Auswahl in der Statusleiste und Kategorie-Validierung
  (Sprunganzahl, erlaubte Sprünge, Level-Caps, Pflichtelemente)
- 60 Adult-Assertions; gesamt 1012 Assertions gruen
- Doku, Findings und Roadmap aktualisiert
This commit is contained in:
torsten 2026-10-31 11:21:18 +01:00
parent 531a057168
commit e4fd74ea6e
25 changed files with 1930 additions and 119 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-basiswert.md` Letzte Session: `docs/findings-2026-10-31-adult-2026-27.md`
(Session davor: `docs/findings-2026-10-31-level-aus-features.md`) (Session davor: `docs/findings-2026-10-31-basiswert.md`)
## 1. Leitentscheidung ## 1. Leitentscheidung
@ -51,7 +51,7 @@ Implementiert in `rinkplanner/src/core/model/`:
| Klasse | Verantwortung | | Klasse | Verantwortung |
| :--- | :--- | | :--- | :--- |
| `Routine` | Wurzelaggregat, Validierung, Gesamtdauer/-länge, Section-Lookup | | `Routine` | Wurzelaggregat, Validierung, Gesamtdauer/-länge, Section-Lookup, Adult-Kategorie |
| `RoutineSection` | chronologischer Block, Ghosting-Einheit, Segmentliste | | `RoutineSection` | chronologischer Block, Ghosting-Einheit, Segmentliste |
| `PathSegment` | durchgehender Pfad mit Richtung, Kante, Dauer, Element-Marker und Label | | `PathSegment` | durchgehender Pfad mit Richtung, Kante, Dauer, Element-Marker und Label |
| `RinkDimensions` | Maße, Koordinaten, Punkte-/Kurvenprüfung | | `RinkDimensions` | Maße, Koordinaten, Punkte-/Kurvenprüfung |
@ -64,6 +64,7 @@ Implementiert in `rinkplanner/src/core/rules/`:
| `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 | | `ElementFeature` | Level-Feature mit Zählgrenze und Programm-Flag |
| `ElementLevelRules` | saisonale Feature-Sätze, Pflichtfeatures und Level-Berechnung | | `ElementLevelRules` | saisonale Feature-Sätze, Pflichtfeatures und Level-Berechnung |
| `AdultCategoryRules` | Adult-Kategorien mit Limits, Level-Caps und Pflichtelementen |
| `RoutineValidator` | prüft Elementdaten gegen Katalog und Level-Regeln | | `RoutineValidator` | prüft Elementdaten gegen Katalog und Level-Regeln |
| `ValidationIssue` | Befund mit Schweregrad, Meldung und Abschnitts-/Segmentbezug | | `ValidationIssue` | Befund mit Schweregrad, Meldung und Abschnitts-/Segmentbezug |
| `ValidationReport` | Befunde, Prüfstatistik und Basiswert-Schätzung | | `ValidationReport` | Befunde, Prüfstatistik und Basiswert-Schätzung |
@ -129,9 +130,9 @@ und Schwellen. Ausgewählte Features liegen als Codes am Segment
(`element_features`); Duplikate sind erlaubt, damit z. B. zwei schwierige (`element_features`); Duplikate sind erlaubt, damit z. B. zwei schwierige
Variationen zwei Features zählen. Für Katalog-Elemente setzt der Controller Variationen zwei Features zählen. Für Katalog-Elemente setzt der Controller
`element_level` automatisch aus dem Feature-Ergebnis; der Level-Regler ist `element_level` automatisch aus dem Feature-Ergebnis; der Level-Regler ist
dann read-only. Sprünge sind fest Base, `ChSq` fest Level 1. Unbekannte dann read-only. Sprünge sind fest Base, `ChSq` und `ChSp` fest Level 1.
Freitext-Codes behalten einen manuellen Level als Fallback; die Validierung Unbekannte Freitext-Codes behalten einen manuellen Level als Fallback; die
meldet dort weiterhin Abweichungen. Validierung meldet dort weiterhin Abweichungen.
**D10 – Validierung liefert Befunde statt eines Ja/Nein.** **D10 – Validierung liefert Befunde statt eines Ja/Nein.**
`RoutineValidator` prüft Elementdaten gegen Katalog und Level-Regeln und `RoutineValidator` prüft Elementdaten gegen Katalog und Level-Regeln und
@ -145,8 +146,16 @@ Die Prüfung ist bewusst getrennt von `Routine.validate()`:
Das Modell prüft Struktur und Pfade, der Validator prüft fachliche Das Modell prüft Struktur und Pfade, der Validator prüft fachliche
Elementdaten. Die Oberfläche zeigt die Prüfliste und die Befunde in einem Elementdaten. Die Oberfläche zeigt die Prüfliste und die Befunde in einem
Dialog; sie blockiert Speichern oder Export nicht. Noch nicht abgedeckt sind Dialog; sie blockiert Speichern oder Export nicht. Noch nicht abgedeckt sind
Programmtypen, Elementanzahl, Wiederholungs-/Kombinationsregeln und die Wiederholungs-/Kombinationsregeln, Dauerprüfung und die Begrenzung auf zwei
Begrenzung auf zwei Features pro Fuß. Features pro Fuß.
**D11 – Adult-Kategorien sind eigene saisonale Daten.**
`AdultCategoryRules` liest das IAFSC-Technical-Announcement als eigene
JSON-Datei. Die Kategorie liegt als `Routine.adult_category` an der Kür und
kann in der Statusleiste gewählt werden. Der Validator prüft Elementanzahl,
erlaubte Sprungrotationen, Level-Caps und Pflichtelemente. Das Announcement
hat bei Konflikten Vorrang vor den allgemeinen ISU-Regeln; deshalb bleiben
Kategorie und Saison getrennte Datenquellen.
## 4. View- und Controller-Grenzen ## 4. View- und Controller-Grenzen
@ -203,11 +212,17 @@ Begrenzung auf zwei Features pro Fuß.
gespeichert. Ein Hinweis zeigt Feature-Anzahl und abgeleitetes Level. gespeichert. Ein Hinweis zeigt Feature-Anzahl und abgeleitetes Level.
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.
- **Kategorie:** Ein Dropdown in der Statusleiste wählt „Ohne Kategorie“,
Bronze, Silver, Gold, Masters oder Masters Elite. Die Auswahl liegt als
`Routine.adult_category` an der Kür, ist undo-fähig und wird mitgespeichert.
Der Prüfdialog nennt Kategorie und Dauer im Kopf.
- **Prüfung:** Der Button „Prüfen“ in der Statusleiste validiert alle - **Prüfung:** Der Button „Prüfen“ in der Statusleiste validiert alle
Elementsegmente gegen Katalog und Level-Regeln. Der Dialog nennt Saison, Elementsegmente gegen Katalog und Level-Regeln. Der Dialog nennt Saison,
Element- und Abschnittszahl und zeigt eine Prüfliste (Kürzel, Elementtyp, Element- und Abschnittszahl und zeigt eine Prüfliste (Kürzel, Elementtyp,
Level, ChSq-Level, Feature-Auswahl, Pflichtfeatures, Level aus Features, Level, ChSq-Level, Feature-Auswahl, Pflichtfeatures, Level aus Features,
Einmal pro Programm) mit „bestanden/geprüft“-Zählern. Nicht anwendbare Einmal pro Programm sowie bei Kategorie: Sprunganzahl, erlaubte Sprünge,
Pirouetten, Sequenzen, Level-Grenzen, Pflichtelemente) mit
„bestanden/geprüft“-Zählern. Nicht anwendbare
Kategorien nennen den Grund (z. B. „keine Features gesetzt“). Darunter Kategorien nennen den Grund (z. B. „keine Features gesetzt“). Darunter
stehen die Befunde mit Abschnitt und Element; ein leeres Ergebnis wird stehen die Befunde mit Abschnitt und Element; ein leeres Ergebnis wird
positiv bestätigt. Der Basiswert zeigt seine Grenzen hinter dem Link positiv bestätigt. Der Basiswert zeigt seine Grenzen hinter dem Link
@ -359,20 +374,22 @@ Aktueller Stand:
- **Model:** 81 Assertions für Rink-Geometrie, Clamping, Segment-Timing, - **Model:** 81 Assertions für Rink-Geometrie, Clamping, Segment-Timing,
Timing-Modi, Template-Metadaten, Element-Marker samt Kürzel-/Level-/Dauer-Grenzen, Timing-Modi, Template-Metadaten, Element-Marker samt Kürzel-/Level-/Dauer-Grenzen,
Schema-Version, Section-Aggregation und Routine-Validierung. Schema-Version, Section-Aggregation und Routine-Validierung.
- **Regelwerk:** 160 Assertions für Katalog-Metadaten, Saison/Quelle, - **Regelwerk:** 166 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, - **Level-Features:** 51 Assertions für Feature-Metadaten, Schwellen,
schwierige Variationen, Level-4-Voraussetzungen, Pflichtfeatures bei schwierige Variationen, Windmills, Level-4-Voraussetzungen, Pflichtfeatures
Schrittsequenzen, feste Level (`ChSq`), Feature-Validierung und die bei Schrittsequenzen, feste Level (`ChSq`, `ChSp`), Feature-Validierung und
Speicherung am Segment. die Speicherung am Segment.
- **Validierung:** 63 Assertions für unbekannte Kürzel, Typ-Mismatches, - **Validierung:** 63 Assertions für unbekannte Kürzel, Typ-Mismatches,
nicht verfügbare Level, Sprung-/ChSq-Sonderfälle, Feature-Fehler, nicht verfügbare Level, Sprung-/ChSq-Sonderfälle, Feature-Fehler,
Pflichtfeatures, Level-Abweichungen, programmweite Einmal-Features, die Pflichtfeatures, Level-Abweichungen, programmweite Einmal-Features, die
Prüfstatistik je Kategorie und die Basiswert-Summe. Prüfstatistik je Kategorie und die Basiswert-Summe.
- **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:** 266 Assertions für Controller-Verdrahtung, Segmenterzeugung, - **Adult-Kategorien:** 60 Assertions für Metadaten, Gold/Silver/Bronze,
Sprungerlaubnis, Level-Caps, Pflichtelemente und unbekannte Kategorien.
- **Whiteboard:** 274 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. Kürzelauswahl, Standzeit, Base-Value- und Typwechsel, Inspector inkl. Kürzelauswahl, Standzeit, Base-Value- und

View file

@ -0,0 +1,109 @@
# Findings – Session: Regeln 2026/27 und Adult-Kategorien (2026-10-31)
Ergänzung zu `docs/findings-2026-10-31-basiswert.md`.
Die App ist auf die für Oberstdorf 2027 gültige Saison **2026/27** umgestellt
und kennt jetzt die Adult-Kategorien mit Gold als Schwerpunkt sowie Silver
und Bronze.
## Ergebnis
| Ziel | Ergebnis |
| :--- | :--- |
| Base Values | ISU Communication 2786 (2026/27) ersetzt 2707 |
| Level-Regeln | ISU Communication 2788 (2026/27) ersetzt 2701 |
| Neues Element | `ChSp1` (Choreographic Spin), fest Level 1, BV 3,50 |
| Adult-Kategorien | Bronze, Silver, Gold, Masters, Masters Elite |
| Fokus | Gold; Silver und Bronze vollständig mitgeprüft |
| Auswahl | Kategorie-Dropdown in der Statusleiste |
| Validierung | Elementanzahl, erlaubte Sprünge, Level-Caps, Pflichtelemente |
| Tests | 1012 Assertions gesamt, `./tools/test.sh` grün |
## Datenupdate 2026/27
- **2786** ersetzt 2707 ab 1. Juli 2026.
- 86 von 110 Base Values geändert; Sprünge unverändert, Pirouetten und
Sequenzen deutlich erhöht.
- `CCoSp4`: 3,50 → 4,20
- `LSp4`: 2,70 → 3,20
- `StSq4`: 3,90 → 4,10
- `ChSq1`: 3,00 → 3,50
- Neue Datei `isu_sov_2026_27.json` mit 43 Familien.
**Level-Regeln 2788:**
- Pirouetten: 15 Features (neu **Windmills**; Layback-Features sind 14/15).
- Schrittsequenzen: 5 Features (neu Körperbewegungen in einer
Drehungs-Kombination).
- Level 4 verlangt jetzt eines von: schwieriger Ausgang, Kantenänderung,
beide Richtungen, Temposteigerung, schwieriger Flug-Eingang, **Windmills**.
- „Schwieriger Positionswechsel“ ist kein Pflicht-Level-4-Feature mehr.
- `ChSp` ist fest Level 1.
## Adult-Kategorien
Die Regeln stehen in `isu_adult_2026_27.json` aus dem IAFSC Technical
Announcement 2026/27. Das Announcement hat bei Konflikten Vorrang vor
allgemeinen ISU-Regeln.
| | Gold | Silver | Bronze |
| :--- | :--- | :--- | :--- |
| Dauer | 2:50 ±10 s | 2:00 ±10 s | 1:40 ±10 s |
| Sprünge | max. 5 | max. 4 | max. 4 |
| Erlaubte Sprünge | Einfach/Double, ohne 2F/2Lz/2A/Triple | nur Einfach inkl. 1A | nur Einfach ohne Axel |
| Pirouetten | max. 3, inkl. ChSp | max. 2 | max. 2 |
| Sequenz | 1 Schrittsequenz | 1 Choreo-Sequenz | 1 Choreo-Sequenz |
| Level-Cap | Spins 3 / Sequenz 2 | 2 / 2 | 1 / 1 |
| PCS-Faktor | 2,67 | 2,00 | 2,00 |
| Sturzabzug | 1,0 | 0,5 außerhalb Elemente | 0,5 außerhalb Elemente |
Zusätzlich sind Masters und Masters Elite in den Daten enthalten.
## Modell und Oberfläche
- `Routine.adult_category` speichert die Kategorie; alte Dateien bleiben
kompatibel (leerer Wert).
- `AdultCategoryRules` lädt die Kategorie-Daten und bietet
`is_jump_allowed()` sowie alle Limits.
- In der Statusleiste gibt es ein Dropdown **Kategorie** mit „Ohne Kategorie“,
Bronze, Silver, Gold, Masters und Masters Elite.
- Die Auswahl ist undo-fähig und wird mit der Kür gespeichert.
- Der Prüfdialog nennt die Kategorie im Kopf, z. B.
`Kategorie: Gold · 2:50 ±10 s`.
## Validierung
Neue Prüfkategorien im Dialog:
- **Kategorie** – Kategorie bekannt
- **Kategorie: Sprunganzahl** – max. Sprungelemente
- **Kategorie: erlaubte Sprünge** – Axel-/Rotations-/Verbote
- **Kategorie: Pirouetten** – max. Pirouetten
- **Kategorie: Sequenzen** – Schritt-/Choreo-Sequenzen
- **Kategorie: Level-Grenzen** – z. B. Gold max. Level 3 bei Spins
- **Kategorie: Pflichtelemente** – Axel (Masters), ChSp (Gold/Masters),
Schritt-/Choreo-Sequenz
Die Befunde sind Warnungen; Speichern und Export bleiben möglich.
## Grenzen
1. **Sprungkombinationen/-folgen** werden gezählt, aber nicht strukturell
geprüft; Wiederholungsregeln fehlen noch.
2. **Dauer** wird angezeigt, aber noch nicht gegen die Kürlänge geprüft.
3. **PCS/Abzüge** sind in den Daten, aber nicht in der Basiswert-Schätzung.
4. **Feature-Level-Caps** werden gemeldet, aber die Feature-Auswahl wird noch
nicht automatisch auf das Kategorie-Maximum begrenzt.
5. **Adult-Announcement** ist die Grundlage; spätere Aktualisierungen müssen
als neue Saisondatei gepflegt werden.
## Tests
- **Katalog:** 166 Assertions (43 Familien, 2026/27-Werte, `ChSp`).
- **Level-Features:** 51 Assertions (15/5 Features, Windmills, Level-4-Liste).
- **Validierung:** 63 Assertions (Basiswerte 2026/27).
- **Adult:** 60 Assertions (Metadaten, Kategorien, Sprungerlaubnis,
Gold-Limits, gültige Gold-Kür, unbekannte Kategorie).
- **Whiteboard:** 274 Assertions (Kategorie-Auswahl, Prüfdialog, Gold-Befunde).
- **Gesamt:** 1012 Assertions.
Visuell geprüft bei 1400 × 876 und 1024 × 768: Kategorie-Dropdown, Kopfzeile
`Kategorie: Gold · 2:50 ±10 s`, Basiswert und Gold-Befunde.

View file

@ -1,15 +1,17 @@
# ISU-Regelwerk – Elementkatalog und Level-Features # ISU-Regelwerk – Elementkatalog, Level-Features und Adult-Kategorien
Stand: 2026-10-31 Stand: 2026-10-31
Saison: **2025/26** Saison: **2026/27** (Oberstdorf 2027)
Quellen: Quellen:
- ISU Communication No. 2707, *Single & Pair Skating – Scale of Values - ISU Communication No. 2786, *Single & Pair Skating – Scale of Values and
valid as of July 1, 2025* (ersetzt Communication 2656) Program Components Factors valid as of July 1, 2026* (ersetzt 2707)
- ISU Communication No. 2701, *Single & Pair Skating – Levels of Difficulty - ISU Communication No. 2788, *Single & Pair Skating – Levels of Difficulty
and Guidelines for marking Grade of Execution and Program Components, and Guidelines for marking Grade of Execution and Program Components,
Season 2025/26* (ersetzt Communication 2623) Season 2026/27* (ersetzt 2701)
- ISU International Adult Figure Skating Competitions 2026/27 –
Technical Announcement (für Oberstdorf 2027)
## Zweck ## Zweck
@ -20,11 +22,10 @@ eine JSON-Datei, nicht den Modell- oder Controller-Code.
Aktuell abgedeckt: Aktuell abgedeckt:
- **24 Sprünge** von `1T` bis `4A` - **24 Sprünge** von `1T` bis `4A`
- **16 Pirouettenfamilien** der Einzel- und Paarlauf-SoV - **17 Pirouettenfamilien** inkl. `ChSp` (Choreographic Spin)
(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-Features** für Pirouetten (15) und Schrittsequenzen (5)
Level-Berechnung nach Feature-Anzahl - **Adult-Kategorien** Bronze, Silver, Gold, Masters, Masters Elite
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
@ -34,24 +35,27 @@ und -folgen, Paarlauf-Hebungen/Twists/Throws sowie Eistanz-Elemente.
| Datei | Inhalt | | Datei | Inhalt |
| :--- | :--- | | :--- | :--- |
| `rinkplanner/src/core/rules/data/isu_sov_2025_26.json` | Katalog mit Base Values | | `rinkplanner/src/core/rules/data/isu_sov_2026_27.json` | Katalog mit Base Values |
| `rinkplanner/src/core/rules/data/isu_levels_2025_26.json` | Level-Features und Schwellen | | `rinkplanner/src/core/rules/data/isu_levels_2026_27.json` | Level-Features und Schwellen |
| `rinkplanner/src/core/rules/data/isu_adult_2026_27.json` | Adult-Kategorien und Limits |
| `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/src/core/rules/element_level_rules.gd` | Feature-Lookup und Level-Berechnung | | `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/src/core/rules/element_feature.gd` | ein Level-Feature mit Zählgrenzen |
| `rinkplanner/src/core/rules/adult_category_rules.gd` | Adult-Kategorien, Limits und Sprungerlaubnis |
| `rinkplanner/tests/run_rules_tests.gd` | Katalog-Tests inkl. Stichproben | | `rinkplanner/tests/run_rules_tests.gd` | Katalog-Tests inkl. Stichproben |
| `rinkplanner/tests/run_level_tests.gd` | Feature- und Level-Tests | | `rinkplanner/tests/run_level_tests.gd` | Feature- und Level-Tests |
| `rinkplanner/tests/run_adult_tests.gd` | Adult-Kategorie-Tests |
## Datenformat ## Datenformat
```json ```json
{ {
"schema_version": 1, "schema_version": 1,
"season": "2025/26", "season": "2026/27",
"discipline": "Single & Pair Skating", "discipline": "Single & Pair Skating",
"valid_from": "2025-07-01", "valid_from": "2026-07-01",
"source": "ISU Communication No. 2707, ...", "source": "ISU Communication No. 2786, ...",
"elements": [ "elements": [
{ {
"code": "3Lz", "code": "3Lz",
@ -64,7 +68,7 @@ und -folgen, Paarlauf-Hebungen/Twists/Throws sowie Eistanz-Elemente.
"name": "Change foot combination spin", "name": "Change foot combination spin",
"type": "spin", "type": "spin",
"base_values": { "base_values": {
"B": 1.70, "1": 2.00, "2": 2.50, "3": 3.00, "4": 3.50 "B": 2.00, "1": 2.40, "2": 3.00, "3": 3.60, "4": 4.20
} }
} }
] ]
@ -85,8 +89,8 @@ und -folgen, Paarlauf-Hebungen/Twists/Throws sowie Eistanz-Elemente.
```gdscript ```gdscript
var catalog := ElementCatalog.load_default() var catalog := ElementCatalog.load_default()
catalog.find("CCoSp") # ElementDefinition oder null catalog.find("CCoSp") # ElementDefinition oder null
catalog.get_base_value("CCoSp", 4) # 3.50 catalog.get_base_value("CCoSp", 4) # 4.20
catalog.get_base_value("CCoSp4", -1) # 3.50 (Level aus Suffix) catalog.get_base_value("CCoSp4", -1) # 4.20 (Level aus Suffix)
catalog.get_base_value("3Lz", 2) # 5.90 (Sprunglevel wird ignoriert) catalog.get_base_value("3Lz", 2) # 5.90 (Sprunglevel wird ignoriert)
catalog.get_base_value("3X") # -1.0 catalog.get_base_value("3X") # -1.0
catalog.get_segment_base_value(segment) # BV eines getaggten Segments catalog.get_segment_base_value(segment) # BV eines getaggten Segments
@ -116,11 +120,16 @@ Level 4 nötig ist.
| Elementtyp | Features | Besonderheit | | Elementtyp | Features | Besonderheit |
| :--- | :--- | :--- | | :--- | :--- | :--- |
| Pirouette | 14 | Max. 2 schwierige Variationen pro Pirouette; Level 4 verlangt eines von 6 bestimmten Features | | Pirouette | 15 | Max. 2 schwierige Variationen; Level 4 verlangt eines von 6 Features inkl. Windmills |
| Schrittsequenz | 4 | Feature 1 (Vielfalt) ist Pflicht; ohne sie bleibt die Sequenz Base | | Schrittsequenz | 5 | Feature 1 (Vielfalt) ist Pflicht; ohne sie bleibt die Sequenz Base |
| `ChSq` | – | Fest Level 1 | | `ChSq` / `ChSp` | – | Fest Level 1 |
| Sprung | – | Nicht levelbar | | Sprung | – | Nicht levelbar |
Für Level 4 bei Pirouetten muss zusätzlich eines dieser Features gezählt
werden: schwieriger Ausgang, klare Kantenänderung, beide Richtungen, klare
Temposteigerung, schwieriger Flug-Eingang oder **Windmills**. Der frühere
„schwierige Positionswechsel“ ist kein Pflichtfeature mehr.
Die Schwelle ist für beide Typen gleich: 1 Feature → Level 1, 2 → Level 2, 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. 3 → Level 3, 4 oder mehr → Level 4. Ohne Feature bleibt das Element Base.
`ElementLevelRules.calculate_level()` liefert neben dem Level auch die `ElementLevelRules.calculate_level()` liefert neben dem Level auch die
@ -140,12 +149,37 @@ Das Segment speichert die Auswahl als `element_features`
(`PackedStringArray`). Duplikate sind erlaubt, damit zwei schwierige (`PackedStringArray`). Duplikate sind erlaubt, damit zwei schwierige
Variationen als zwei Features zählen. Für Katalog-Elemente setzt der Variationen als zwei Features zählen. Für Katalog-Elemente setzt der
Controller den Level automatisch aus dem Feature-Ergebnis. Sprünge sind fest Controller den Level automatisch aus dem Feature-Ergebnis. Sprünge sind fest
Base, `ChSq` fest Level 1. Unbekannte Freitext-Codes behalten einen manuellen Base, `ChSq` und `ChSp` fest Level 1. Unbekannte Freitext-Codes behalten
Level als Fallback. Die Daten enthalten außerdem `once_per_program` (Feature einen manuellen Level als Fallback. Die Daten enthalten außerdem
zählt nur beim ersten Versuch im Programm) und `max_per_element`. Die `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 Programmprüfung und die Begrenzung „max. zwei Features pro Fuß“ sind noch
nicht umgesetzt. nicht umgesetzt.
## Adult-Kategorien
Die Adult-Regeln liegen als eigene Datei aus dem IAFSC Technical Announcement
2026/27. Das Announcement hat bei Konflikten Vorrang vor den allgemeinen
ISU-Regeln. Die Kategorie wird über `Routine.adult_category` an der Kür
gespeichert und in der Statusleiste gewählt.
| | Gold | Silver | Bronze |
| :--- | :--- | :--- | :--- |
| Dauer | 2:50 ±10 s | 2:00 ±10 s | 1:40 ±10 s |
| Sprünge | max. 5 | max. 4 | max. 4 |
| Erlaubt | Einfach/Double, ohne 2F/2Lz/2A/Triple | nur Einfach inkl. 1A | nur Einfach ohne Axel |
| Pirouetten | max. 3, inkl. `ChSp` | max. 2 | max. 2 |
| Sequenz | 1 Schrittsequenz | 1 Choreo-Sequenz | 1 Choreo-Sequenz |
| Level-Cap | Spins 3 / Sequenz 2 | 2 / 2 | 1 / 1 |
| PCS-Faktor | 2,67 | 2,00 | 2,00 |
| Sturzabzug | 1,0 | 0,5 außerhalb Elemente | 0,5 außerhalb Elemente |
Masters und Masters Elite sind ebenfalls in den Daten. Der Validator prüft
Sprunganzahl, erlaubte Rotationen (inkl. Axel-Verbot), Pirouetten- und
Sequenzanzahl, Level-Caps und Pflichtelemente wie `ChSp` oder Axel. Die
Befunde erscheinen als Warnungen im Prüfdialog; Speichern und Export bleiben
möglich.
## Bedienung ## Bedienung
Der Element-Inspector bietet für das Kürzel eine Auswahlbox mit den Familien Der Element-Inspector bietet für das Kürzel eine Auswahlbox mit den Familien
@ -155,8 +189,8 @@ Kombinationen und Varianten, die der Katalog nicht strukturiert abbildet
er blendet das bisherige Textfeld ein. Beim Übernehmen werden Level-Suffixe er blendet das bisherige Textfeld ein. Beim Übernehmen werden Level-Suffixe
weiterhin ins Level-Feld normalisiert. weiterhin ins Level-Feld normalisiert.
Der Inspector zeigt unter der Level-Auswahl `Base Value: 3,50`. Der Inspector zeigt unter der Level-Auswahl `Base Value: 4,20`.
Unbekannte Kürzel erscheinen als „Kürzel nicht im Katalog 2025/26“. Der Unbekannte Kürzel erscheinen als „Kürzel nicht im Katalog 2026/27“. Der
Hinweis aktualisiert sich bei Änderungen an Typ, Kürzel und Features; der Hinweis aktualisiert sich bei Änderungen an Typ, Kürzel und Features; der
Tooltip nennt Saison und Quelle. Tooltip nennt Saison und Quelle.
@ -174,15 +208,18 @@ und liefert `ValidationIssue`-Befunde mit Schweregrad, Meldung und Bezug zu
Abschnitt und Segment. Geprüft werden: Abschnitt und Segment. Geprüft werden:
- unbekannte Kürzel und Kürzel mit falschem Elementtyp - unbekannte Kürzel und Kürzel mit falschem Elementtyp
- nicht verfügbare Level, Sprung-Level ungleich 0 und das feste Level von `ChSq` - nicht verfügbare Level, Sprung-Level ungleich 0 und die festen Level von
`ChSq`/`ChSp`
- unbekannte Features, zu häufige Features und fehlende Pflichtfeatures - unbekannte Features, zu häufige Features und fehlende Pflichtfeatures
- Abweichungen zwischen Feature-Ergebnis und gewähltem Level - Abweichungen zwischen Feature-Ergebnis und gewähltem Level
- Features, die laut Daten nur einmal pro Programm zählen - Features, die laut Daten nur einmal pro Programm zählen
- bei gewählter Adult-Kategorie: Sprunganzahl, erlaubte Sprünge,
Pirouetten-/Sequenzanzahl, Level-Caps und Pflichtelemente
Der Button **Prüfen** in der Statusleiste öffnet die Befunde in einem Dialog. Der Button **Prüfen** in der Statusleiste öffnet die Befunde in einem Dialog.
Der Kopf nennt den Umfang (`Geprüft: 4 Elemente in 1 Abschnitt (Saison Der Kopf nennt Umfang und Kategorie (`Geprüft: 4 Elemente in 1 Abschnitt
2025/26)`), darunter listet die Prüfliste jede Kategorie mit (Saison 2026/27)`, `Kategorie: Gold · 2:50 ±10 s`), darunter listet die
`bestanden/geprüft` und Befundzahl: Prüfliste jede Kategorie mit `bestanden/geprüft` und Befundzahl:
- Kürzel im Katalog - Kürzel im Katalog
- Elementtyp passt - Elementtyp passt
@ -192,6 +229,8 @@ Der Kopf nennt den Umfang (`Geprüft: 4 Elemente in 1 Abschnitt (Saison
- Pflichtfeatures - Pflichtfeatures
- Level aus Features - Level aus Features
- Einmal pro Programm - Einmal pro Programm
- Kategorie: Sprunganzahl, erlaubte Sprünge, Pirouetten, Sequenzen,
Level-Grenzen, Pflichtelemente
Nicht anwendbare Kategorien nennen den Grund, z. B. „nicht anwendbar (kein Nicht anwendbare Kategorien nennen den Grund, z. B. „nicht anwendbar (kein
ChSq)“ oder „nicht anwendbar (keine Features gesetzt)“. Erst danach folgen ChSq)“ oder „nicht anwendbar (keine Features gesetzt)“. Erst danach folgen
@ -203,7 +242,7 @@ Der Prüfdialog zeigt zusätzlich eine **Basiswert-Schätzung**:
- Summe der Base Values aller Elemente mit gültigem Katalogwert - Summe der Base Values aller Elemente mit gültigem Katalogwert
- Anzahl gewerteter und nicht gewerteter Elemente - Anzahl gewerteter und nicht gewerteter Elemente
- Wertungsliste pro Element (`CCoSp L4 — 3,50`, `ChStSq — —`) - Wertungsliste pro Element (`CCoSp L4 — 4,20`, `ChStSq — —`)
Die Schätzung enthält **keine** GOE, keinen 1,1-Faktor für die zweite Die Schätzung enthält **keine** GOE, keinen 1,1-Faktor für die zweite
Programmhälfte, keine Programmkomponenten und keine Abzüge. Freitext- und Programmhälfte, keine Programmkomponenten und keine Abzüge. Freitext- und
@ -213,22 +252,25 @@ Gesamtpunktzahl.
Der Link **ⓘ Was ist enthalten?** klappt diese Grenzen direkt im Prüfdialog Der Link **ⓘ Was ist enthalten?** klappt diese Grenzen direkt im Prüfdialog
auf; ein zweiter Klick blendet sie wieder aus. Noch nicht geprüft werden auf; ein zweiter Klick blendet sie wieder aus. Noch nicht geprüft werden
Programmtyp, erlaubte Elementanzahl, Wiederholungs- und Kombinationsregeln Dauer, Wiederholungs- und Kombinationsregeln sowie die Begrenzung auf zwei
sowie die Begrenzung auf zwei Features pro Fuß. Features pro Fuß.
## 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
obigen Schema anlegen, z. B. `isu_sov_2026_27.json`. obigen Schema anlegen, z. B. `isu_sov_2027_28.json`.
2. `season`, `valid_from` und `source` aktualisieren. 2. `season`, `valid_from` und `source` aktualisieren.
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. Neue Level-Communication (Levels of Difficulty) als 5. Neue Level-Communication (Levels of Difficulty) als
`isu_levels_2026_27.json` anlegen, `ElementLevelRules.DEFAULT_PATH` `isu_levels_2027_28.json` anlegen, `ElementLevelRules.DEFAULT_PATH`
umstellen und `tests/run_level_tests.gd` anpassen. umstellen und `tests/run_level_tests.gd` anpassen.
6. `./tools/test.sh` ausführen. 6. Adult-Announcement der Saison als `isu_adult_2027_28.json` anlegen,
7. Die alte Datei kann für Nachvollziehbarkeit im Repo bleiben; aktiv ist `AdultCategoryRules.DEFAULT_PATH` umstellen und
`tests/run_adult_tests.gd` anpassen.
7. `./tools/test.sh` ausführen.
8. Die alte Datei kann für Nachvollziehbarkeit im Repo bleiben; aktiv ist
immer genau eine Datei pro Regelart. immer genau eine Datei pro Regelart.
Die JSON-Dateien werden über `include_filter="*.json"` in allen Export-Presets Die JSON-Dateien werden über `include_filter="*.json"` in allen Export-Presets
@ -237,9 +279,9 @@ mit ausgeliefert.
## Nächste Ausbaustufen ## Nächste Ausbaustufen
- Max. zwei Features pro Fuß und Feature-Positionsregeln - Max. zwei Features pro Fuß und Feature-Positionsregeln
- Programmtypen, erlaubte Elementanzahl sowie Wiederholungs- und - Wiederholungs- und Kombinationsregeln
Kombinationsregeln - Dauerprüfung gegen die Kategorie-Zeit
- PCS und Sturzabzüge in der Punktschätzung
- GOE-Tabellen und `V`-/Unterrotations-Varianten - GOE-Tabellen und `V`-/Unterrotations-Varianten
- Sprungkombinationen und -folgen als zusammengesetzte Elemente - Sprungkombinationen und -folgen als zusammengesetzte Elemente
- Adult-spezifische Programmregeln
- Vorschlagsliste im Inspector direkt aus `suggest()` - Vorschlagsliste im Inspector direkt aus `suggest()`

View file

@ -1,9 +1,9 @@
# Rinkplanner – Roadmap # Rinkplanner – Roadmap
Stand: 2026-10-31 (ISU-Katalog, Level-Features und Elementvalidierung; Sync-Komfort und UI-Refactoring zurückgestellt) Stand: 2026-10-31 (ISU 2026/27, Adult-Kategorien Gold/Silver/Bronze; 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-31-adult-2026-27.md`.
## Leitprinzip ## Leitprinzip
@ -110,25 +110,30 @@ Voraussetzung für Phase 1.
### In Arbeit: ISU-Regelwerk ### In Arbeit: ISU-Regelwerk
- [x] Elementkatalog als strukturierte Daten (JSON/Resources) - [x] Elementkatalog als strukturierte Daten (JSON/Resources)
– Saison 2025/26 mit 24 Sprüngen, 16 Pirouetten und 2 Sequenzen; – Saison 2026/27 mit 24 Sprüngen, 17 Pirouetten (inkl. `ChSp`) und
Format und Pflege in `docs/isu-rules.md` 2 Sequenzen; Format und Pflege in `docs/isu-rules.md`
- [x] Base Values und Level je Elementfamilie - [x] Base Values und Level je Elementfamilie
- [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
- [x] Features und Kriterien für die Level-Vergabe - [x] Features und Kriterien für die Level-Vergabe
– Pirouetten (14 Features) und Schrittsequenzen (4 Features), – Pirouetten (15 Features) und Schrittsequenzen (5 Features),
Level-Berechnung und Auswahl im Inspector; Details in `docs/isu-rules.md` Level-Berechnung und Auswahl im Inspector; Details in `docs/isu-rules.md`
- [x] Level automatisch aus Features (Pirouetten/Sequenzen), Sprünge Base, - [x] Level automatisch aus Features (Pirouetten/Sequenzen), Sprünge Base,
`ChSq` Level 1; manueller Level nur für Freitext-Codes `ChSq`/`ChSp` Level 1; manueller Level nur für Freitext-Codes
- [x] Validierung von Elementen (Katalog, Level, Features, Level-Abgleich) - [x] Validierung von Elementen (Katalog, Level, Features, Level-Abgleich)
mit Prüfdialog in der Statusleiste mit Prüfdialog in der Statusleiste
- [x] Basiswert-Schätzung im Prüfdialog (Summe ohne GOE, 1,1-Faktor, - [x] Basiswert-Schätzung im Prüfdialog (Summe ohne GOE, 1,1-Faktor,
Komponenten und Abzüge) Komponenten und Abzüge)
- [x] Programmweite Einmal-Features (`once_per_program`) als Warnung - [x] Programmweite Einmal-Features (`once_per_program`) als Warnung
- [x] Update auf ISU 2026/27 (Communication 2786/2788) inkl. `ChSp1`
- [x] Adult-Kategorien Bronze/Silver/Gold (plus Masters/Elite) mit Dauer,
Elementlimits, erlaubten Sprüngen, Level-Caps und Pflichtelementen
- [x] Kategorie-Auswahl in der Statusleiste und Kategorie-Prüfungen
- [ ] Max. zwei Features pro Fuß und Feature-Positionsregeln - [ ] Max. zwei Features pro Fuß und Feature-Positionsregeln
- [ ] Kombinations-, Wiederholungs- und Programmtyp-Regeln - [ ] Wiederholungs- und Kombinationsregeln
- [x] Kürzelauswahl im Inspector (Katalog-Dropdown mit Freitext-Fallback) - [ ] Dauerprüfung gegen die Kategorie-Zeit
- [ ] PCS und Sturzabzüge in der Punktschätzung
- [ ] Optional: Suchfeld/Autovervollständigung aus `suggest()` - [ ] Optional: Suchfeld/Autovervollständigung aus `suggest()`
- [ ] Optional: GOE-Tabellen sowie `V`-/Unterrotationsvarianten - [ ] Optional: GOE-Tabellen sowie `V`-/Unterrotationsvarianten
@ -154,11 +159,12 @@ 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 – Katalog, Level-Features sind erledigt. Im PoC läuft jetzt das ISU-Regelwerk – Katalog 2026/27,
und Elementvalidierung stehen; als Nächstes folgen Programmregeln und Level-Features, Elementvalidierung und Adult-Kategorien stehen; als Nächstes
Kombinationen. Sync-Komfort und UI-Refactoring sind zurückgestellt, weil der folgen Wiederholungs-/Kombinationsregeln und die Dauerprüfung. Sync-Komfort
bestehende Stand für Tests genügt und die endgültige Sync-Architektur und UI-Refactoring sind zurückgestellt, weil der bestehende Stand für Tests
(PHP-Webserver) sowie das UI-Feedback der Tester ohnehin noch ausstehen. genügt und die endgültige Sync-Architektur (PHP-Webserver) sowie das
UI-Feedback der Tester ohnehin noch ausstehen.
## Querschnittsaufgaben ## Querschnittsaufgaben

View file

@ -502,6 +502,12 @@ theme_override_font_sizes/font_size = 15
text = "Abschnitt 1 · 0 Segmente" text = "Abschnitt 1 · 0 Segmente"
vertical_alignment = 1 vertical_alignment = 1
[node name="AdultCategoryOption" type="OptionButton" parent="Layout/StatusBar/StatusBarContent"]
unique_name_in_owner = true
custom_minimum_size = Vector2(170, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 15
[node name="ValidationButton" type="Button" parent="Layout/StatusBar/StatusBarContent"] [node name="ValidationButton" type="Button" parent="Layout/StatusBar/StatusBarContent"]
unique_name_in_owner = true unique_name_in_owner = true
custom_minimum_size = Vector2(120, 56) custom_minimum_size = Vector2(120, 56)

View file

@ -10,6 +10,9 @@ const CURRENT_SCHEMA_VERSION := 2
@export var routine_id: String = "" @export var routine_id: String = ""
@export var title: String = "" @export var title: String = ""
@export var skater_name: String = "" @export var skater_name: String = ""
## Adult competition category code (e.g. "gold", "silver", "bronze"). Empty
## means no category-specific validation.
@export var adult_category: String = ""
@export var rink: RinkDimensions = RinkDimensions.new() @export var rink: RinkDimensions = RinkDimensions.new()
@export var sections: Array[RoutineSection] = [] @export var sections: Array[RoutineSection] = []

View file

@ -0,0 +1,245 @@
class_name AdultCategoryRules
extends RefCounted
## Adult competition categories and their program limits for one season.
##
## The data comes from the ISU International Adult Figure Skating Competitions
## technical announcement. It covers element counts, allowed jump rotations,
## level caps, required elements and scoring factors. Combination and
## repetition details are stored but validated only in later stages.
const DEFAULT_PATH := "res://src/core/rules/data/isu_adult_2026_27.json"
const SUPPORTED_SCHEMA_VERSION := 1
const ROTATION_NAMES := ["", "single", "double", "triple", "quad"]
class Category extends RefCounted:
var code: String = ""
var name: String = ""
var duration_seconds: int = 0
var duration_tolerance_seconds: int = 10
var max_jump_elements: int = 0
var allowed_rotations: PackedStringArray = PackedStringArray()
var allow_axel: bool = true
var forbidden_jumps: PackedStringArray = PackedStringArray()
var required_axel: bool = false
var max_jump_combinations: int = 0
var max_jump_sequences: int = 0
var max_jumps_per_combination: int = 0
var max_spins: int = 0
var max_step_sequences: int = 0
var max_choreographic_sequences: int = 0
var required_step_sequences: int = 0
var required_choreographic_sequences: int = 0
var requires_choreographic_spin: bool = false
var max_spin_level: int = 0
var max_sequence_level: int = 0
var pcs_factor: float = 0.0
var fall_deduction: float = 0.0
static func jump_rotation(code: String) -> int:
var cleaned := code.strip_edges()
if cleaned.length() < 2:
return 0
var first := cleaned.substr(0, 1)
if not first.is_valid_int():
return 0
var rotation := int(first)
if rotation < 1 or rotation > 4:
return 0
return rotation
static func jump_type(code: String) -> String:
var cleaned := code.strip_edges()
if cleaned.length() < 2:
return ""
return cleaned.substr(1)
func is_jump_allowed(code: String) -> bool:
var cleaned := code.strip_edges()
if cleaned.is_empty() or cleaned.contains("+"):
return true
var rotation := jump_rotation(cleaned)
if rotation <= 0:
return true
if not allowed_rotations.has(ROTATION_NAMES[rotation]):
return false
if jump_type(cleaned) == "A" and not allow_axel:
return false
return not forbidden_jumps.has(cleaned)
func validate() -> PackedStringArray:
var errors := PackedStringArray()
if code.strip_edges().is_empty():
errors.append("code must not be empty")
if name.strip_edges().is_empty():
errors.append("name must not be empty")
if duration_seconds <= 0:
errors.append("duration_seconds must be positive")
for rotation: String in allowed_rotations:
if not ROTATION_NAMES.has(rotation):
errors.append("unknown jump rotation '%s'" % rotation)
if max_spin_level < 0 or max_spin_level > PathSegment.ELEMENT_MAX_LEVEL:
errors.append("max_spin_level is out of range")
if max_sequence_level < 0 or max_sequence_level > PathSegment.ELEMENT_MAX_LEVEL:
errors.append("max_sequence_level is out of range")
return errors
var schema_version: int = 0
var season: String = ""
var source: String = ""
var valid_from: String = ""
var _categories: Array[Category] = []
var _by_code: Dictionary[String, Category] = {}
var _errors: PackedStringArray = PackedStringArray()
static func load_default() -> AdultCategoryRules:
return load_from(DEFAULT_PATH)
static func load_from(path: String) -> AdultCategoryRules:
var rules := AdultCategoryRules.new()
rules._parse_file(path)
return rules
func get_categories() -> Array[Category]:
var copy: Array[Category] = []
copy.assign(_categories)
return copy
func get_category(code: String) -> Category:
return _by_code.get(code.strip_edges().to_lower(), null)
func has_category(code: String) -> bool:
return get_category(code) != null
func get_errors() -> PackedStringArray:
return _errors.duplicate()
func validate() -> PackedStringArray:
var errors := _errors.duplicate()
if schema_version != SUPPORTED_SCHEMA_VERSION:
errors.append(
"unsupported adult-category schema %d (expected %d)"
% [schema_version, SUPPORTED_SCHEMA_VERSION]
)
if season.strip_edges().is_empty():
errors.append("adult-category season must not be empty")
if source.strip_edges().is_empty():
errors.append("adult-category source must not be empty")
if _categories.is_empty():
errors.append("adult-category rules contain no categories")
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 adult categories '%s'" % path)
return
var json := JSON.new()
var error := json.parse(file.get_as_text())
if error != OK:
_errors.append(
"invalid adult-category JSON at line %d: %s"
% [json.get_error_line(), json.get_error_message()]
)
return
if typeof(json.data) != TYPE_DICTIONARY:
_errors.append("adult-category 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()
source = str(data.get("source", "")).strip_edges()
valid_from = str(data.get("valid_from", "")).strip_edges()
var entries: Variant = data.get("categories", [])
if typeof(entries) != TYPE_ARRAY:
_errors.append("adult-category 'categories' must be an array")
return
for entry: Variant in entries:
if typeof(entry) != TYPE_DICTIONARY:
_errors.append("adult-category entry must be an object")
continue
var category := _parse_category(entry as Dictionary)
if category == null:
continue
for message: String in category.validate():
_errors.append("%s: %s" % [category.code, message])
var key := category.code.to_lower()
if _by_code.has(key):
_errors.append("duplicate adult category '%s'" % category.code)
continue
_by_code[key] = category
_categories.append(category)
func _parse_category(entry: Dictionary) -> Category:
var category := Category.new()
category.code = str(entry.get("code", "")).strip_edges()
category.name = str(entry.get("name", "")).strip_edges()
category.duration_seconds = int(entry.get("duration_seconds", 0))
category.duration_tolerance_seconds = int(
entry.get("duration_tolerance_seconds", 10)
)
category.max_jump_elements = int(entry.get("max_jump_elements", 0))
category.allowed_rotations = _to_string_array(
entry.get("allowed_rotations", [])
)
category.allow_axel = bool(entry.get("allow_axel", true))
category.forbidden_jumps = _to_string_array(
entry.get("forbidden_jumps", [])
)
category.required_axel = bool(entry.get("required_axel", false))
category.max_jump_combinations = int(
entry.get("max_jump_combinations", 0)
)
category.max_jump_sequences = int(entry.get("max_jump_sequences", 0))
category.max_jumps_per_combination = int(
entry.get("max_jumps_per_combination", 0)
)
category.max_spins = int(entry.get("max_spins", 0))
category.max_step_sequences = int(entry.get("max_step_sequences", 0))
category.max_choreographic_sequences = int(
entry.get("max_choreographic_sequences", 0)
)
category.required_step_sequences = int(
entry.get("required_step_sequences", 0)
)
category.required_choreographic_sequences = int(
entry.get("required_choreographic_sequences", 0)
)
category.requires_choreographic_spin = bool(
entry.get("requires_choreographic_spin", false)
)
category.max_spin_level = int(entry.get("max_spin_level", 0))
category.max_sequence_level = int(entry.get("max_sequence_level", 0))
category.pcs_factor = float(entry.get("pcs_factor", 0.0))
category.fall_deduction = float(entry.get("fall_deduction", 0.0))
return category
static func _to_string_array(values: Variant) -> PackedStringArray:
var result := PackedStringArray()
if typeof(values) != TYPE_ARRAY:
return result
for value: Variant in values as Array:
var cleaned := str(value).strip_edges()
if not cleaned.is_empty():
result.append(cleaned)
return result

View file

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

View file

@ -0,0 +1,128 @@
{
"schema_version": 1,
"season": "2026/27",
"source": "ISU International Adult Figure Skating Competitions 2026/27 – Technical Announcement",
"valid_from": "2026-07-01",
"categories": [
{
"code": "bronze",
"name": "Bronze",
"duration_seconds": 100,
"duration_tolerance_seconds": 10,
"max_jump_elements": 4,
"allowed_rotations": ["single"],
"allow_axel": false,
"forbidden_jumps": [],
"required_axel": false,
"max_jump_combinations": 1,
"max_jump_sequences": 0,
"max_jumps_per_combination": 2,
"max_spins": 2,
"max_step_sequences": 0,
"max_choreographic_sequences": 1,
"required_step_sequences": 0,
"required_choreographic_sequences": 1,
"requires_choreographic_spin": false,
"max_spin_level": 1,
"max_sequence_level": 1,
"pcs_factor": 2.0,
"fall_deduction": 0.5
},
{
"code": "silver",
"name": "Silver",
"duration_seconds": 120,
"duration_tolerance_seconds": 10,
"max_jump_elements": 4,
"allowed_rotations": ["single"],
"allow_axel": true,
"forbidden_jumps": [],
"required_axel": false,
"max_jump_combinations": 2,
"max_jump_sequences": 1,
"max_jumps_per_combination": 3,
"max_spins": 2,
"max_step_sequences": 0,
"max_choreographic_sequences": 1,
"required_step_sequences": 0,
"required_choreographic_sequences": 1,
"requires_choreographic_spin": false,
"max_spin_level": 2,
"max_sequence_level": 2,
"pcs_factor": 2.0,
"fall_deduction": 0.5
},
{
"code": "gold",
"name": "Gold",
"duration_seconds": 170,
"duration_tolerance_seconds": 10,
"max_jump_elements": 5,
"allowed_rotations": ["single", "double"],
"allow_axel": true,
"forbidden_jumps": ["2F", "2Lz", "2A"],
"required_axel": false,
"max_jump_combinations": 2,
"max_jump_sequences": 1,
"max_jumps_per_combination": 3,
"max_spins": 3,
"max_step_sequences": 1,
"max_choreographic_sequences": 0,
"required_step_sequences": 1,
"required_choreographic_sequences": 0,
"requires_choreographic_spin": true,
"max_spin_level": 3,
"max_sequence_level": 2,
"pcs_factor": 2.67,
"fall_deduction": 1.0
},
{
"code": "masters",
"name": "Masters",
"duration_seconds": 180,
"duration_tolerance_seconds": 10,
"max_jump_elements": 5,
"allowed_rotations": ["single", "double"],
"allow_axel": true,
"forbidden_jumps": [],
"required_axel": true,
"max_jump_combinations": 2,
"max_jump_sequences": 1,
"max_jumps_per_combination": 3,
"max_spins": 3,
"max_step_sequences": 1,
"max_choreographic_sequences": 0,
"required_step_sequences": 1,
"required_choreographic_sequences": 0,
"requires_choreographic_spin": true,
"max_spin_level": 4,
"max_sequence_level": 4,
"pcs_factor": 2.67,
"fall_deduction": 1.0
},
{
"code": "masters_elite",
"name": "Masters Elite",
"duration_seconds": 180,
"duration_tolerance_seconds": 10,
"max_jump_elements": 5,
"allowed_rotations": ["single", "double", "triple"],
"allow_axel": true,
"forbidden_jumps": [],
"required_axel": true,
"max_jump_combinations": 2,
"max_jump_sequences": 1,
"max_jumps_per_combination": 3,
"max_spins": 3,
"max_step_sequences": 1,
"max_choreographic_sequences": 0,
"required_step_sequences": 1,
"required_choreographic_sequences": 0,
"requires_choreographic_spin": true,
"max_spin_level": 4,
"max_sequence_level": 4,
"pcs_factor": 2.67,
"fall_deduction": 1.0
}
]
}

View file

@ -0,0 +1,192 @@
{
"schema_version": 1,
"season": "2026/27",
"discipline": "Single Skating",
"valid_from": "2026-06-01",
"source": "ISU Communication No. 2788, Levels of Difficulty and Guidelines for marking Grade of Execution and Program Components, Season 2026/27",
"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,
"ChSp": 1
},
"types": {
"spin": {
"required_features": [],
"level4_requires_any": [
"difficult_exit",
"change_of_edge",
"both_directions",
"increase_speed",
"difficult_flying_entry",
"windmills"
],
"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": "windmills",
"name": "Windmills",
"description": "Windmills, dreimal hintereinander; jede Bewegung nahe am Spagat (mind. 135°). Zählt einmal pro Programm.",
"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
},
{
"code": "body_movements_in_turns",
"name": "Körperbewegungen in Drehungs-Kombination",
"description": "Körperbewegungen in einer Kombination aus 3 schwierigen Drehungen.",
"max_per_element": 1,
"once_per_program": true
}
]
}
}
}

View file

@ -0,0 +1,373 @@
{
"schema_version": 1,
"season": "2026/27",
"discipline": "Single & Pair Skating",
"valid_from": "2026-07-01",
"source": "ISU Communication No. 2786, Scale of Values and Program Components Factors valid as of July 1, 2026",
"elements": [
{
"code": "1T",
"name": "Single toe loop",
"type": "jump",
"base_value": 0.4
},
{
"code": "1S",
"name": "Single Salchow",
"type": "jump",
"base_value": 0.4
},
{
"code": "1Lo",
"name": "Single loop",
"type": "jump",
"base_value": 0.5
},
{
"code": "1F",
"name": "Single flip",
"type": "jump",
"base_value": 0.5
},
{
"code": "1Lz",
"name": "Single Lutz",
"type": "jump",
"base_value": 0.6
},
{
"code": "1A",
"name": "Single Axel",
"type": "jump",
"base_value": 1.1
},
{
"code": "2T",
"name": "Double toe loop",
"type": "jump",
"base_value": 1.3
},
{
"code": "2S",
"name": "Double Salchow",
"type": "jump",
"base_value": 1.3
},
{
"code": "2Lo",
"name": "Double loop",
"type": "jump",
"base_value": 1.7
},
{
"code": "2F",
"name": "Double flip",
"type": "jump",
"base_value": 1.8
},
{
"code": "2Lz",
"name": "Double Lutz",
"type": "jump",
"base_value": 2.1
},
{
"code": "2A",
"name": "Double Axel",
"type": "jump",
"base_value": 3.3
},
{
"code": "3T",
"name": "Triple toe loop",
"type": "jump",
"base_value": 4.2
},
{
"code": "3S",
"name": "Triple Salchow",
"type": "jump",
"base_value": 4.3
},
{
"code": "3Lo",
"name": "Triple loop",
"type": "jump",
"base_value": 4.9
},
{
"code": "3F",
"name": "Triple flip",
"type": "jump",
"base_value": 5.3
},
{
"code": "3Lz",
"name": "Triple Lutz",
"type": "jump",
"base_value": 5.9
},
{
"code": "3A",
"name": "Triple Axel",
"type": "jump",
"base_value": 8.0
},
{
"code": "4T",
"name": "Quadruple toe loop",
"type": "jump",
"base_value": 9.5
},
{
"code": "4S",
"name": "Quadruple Salchow",
"type": "jump",
"base_value": 9.7
},
{
"code": "4Lo",
"name": "Quadruple loop",
"type": "jump",
"base_value": 10.5
},
{
"code": "4F",
"name": "Quadruple flip",
"type": "jump",
"base_value": 11.0
},
{
"code": "4Lz",
"name": "Quadruple Lutz",
"type": "jump",
"base_value": 11.5
},
{
"code": "4A",
"name": "Quadruple Axel",
"type": "jump",
"base_value": 12.5
},
{
"code": "USp",
"name": "Upright spin",
"type": "spin",
"base_values": {
"B": 1.2,
"1": 1.4,
"2": 1.8,
"3": 2.3,
"4": 2.9
}
},
{
"code": "LSp",
"name": "Layback spin",
"type": "spin",
"base_values": {
"B": 1.4,
"1": 1.8,
"2": 2.3,
"3": 2.9,
"4": 3.2
}
},
{
"code": "CSp",
"name": "Camel spin",
"type": "spin",
"base_values": {
"B": 1.3,
"1": 1.7,
"2": 2.2,
"3": 2.8,
"4": 3.1
}
},
{
"code": "SSp",
"name": "Sit spin",
"type": "spin",
"base_values": {
"B": 1.3,
"1": 1.6,
"2": 1.9,
"3": 2.5,
"4": 3.0
}
},
{
"code": "FUSp",
"name": "Flying upright spin",
"type": "spin",
"base_values": {
"B": 1.8,
"1": 2.0,
"2": 2.4,
"3": 2.9,
"4": 3.5
}
},
{
"code": "FLSp",
"name": "Flying layback spin",
"type": "spin",
"base_values": {
"B": 2.0,
"1": 2.4,
"2": 2.9,
"3": 3.5,
"4": 3.8
}
},
{
"code": "FCSp",
"name": "Flying camel spin",
"type": "spin",
"base_values": {
"B": 1.9,
"1": 2.3,
"2": 2.8,
"3": 3.4,
"4": 3.8
}
},
{
"code": "FSSp",
"name": "Flying sit spin",
"type": "spin",
"base_values": {
"B": 2.0,
"1": 2.4,
"2": 2.8,
"3": 3.1,
"4": 3.6
}
},
{
"code": "CUSp",
"name": "Change foot upright spin",
"type": "spin",
"base_values": {
"B": 1.8,
"1": 2.0,
"2": 2.4,
"3": 2.9,
"4": 3.5
}
},
{
"code": "FCUSp",
"name": "Flying change foot upright spin",
"type": "spin",
"base_values": {
"B": 1.8,
"1": 2.0,
"2": 2.4,
"3": 2.9,
"4": 3.5
}
},
{
"code": "CLSp",
"name": "Change foot layback spin",
"type": "spin",
"base_values": {
"B": 2.0,
"1": 2.4,
"2": 2.9,
"3": 3.5,
"4": 3.8
}
},
{
"code": "FCLSp",
"name": "Flying change foot layback spin",
"type": "spin",
"base_values": {
"B": 2.0,
"1": 2.4,
"2": 2.9,
"3": 3.5,
"4": 3.8
}
},
{
"code": "CoSp",
"name": "Combination spin",
"type": "spin",
"base_values": {
"B": 1.8,
"1": 2.0,
"2": 2.4,
"3": 3.0,
"4": 3.6
}
},
{
"code": "FCoSp",
"name": "Flying combination spin",
"type": "spin",
"base_values": {
"B": 1.8,
"1": 2.0,
"2": 2.4,
"3": 3.0,
"4": 3.6
}
},
{
"code": "CCoSp",
"name": "Change foot combination spin",
"type": "spin",
"base_values": {
"B": 2.0,
"1": 2.4,
"2": 3.0,
"3": 3.6,
"4": 4.2
}
},
{
"code": "FCCoSp",
"name": "Flying change foot combination spin",
"type": "spin",
"base_values": {
"B": 2.0,
"1": 2.4,
"2": 3.0,
"3": 3.6,
"4": 4.2
}
},
{
"code": "StSq",
"name": "Step sequence",
"type": "sequence",
"base_values": {
"B": 1.6,
"1": 1.9,
"2": 2.7,
"3": 3.5,
"4": 4.1
}
},
{
"code": "ChSq",
"name": "Choreographic sequence",
"type": "sequence",
"base_values": {
"1": 3.5
}
},
{
"code": "ChSp",
"name": "Choreographic spin",
"type": "spin",
"base_values": {
"1": 3.5
}
}
]
}

View file

@ -9,7 +9,7 @@ extends RefCounted
## a level suffix ("CCoSp4", "StSqB"). Jump levels are ignored because jumps ## a level suffix ("CCoSp4", "StSqB"). Jump levels are ignored because jumps
## have a single base value. ## have a single base value.
const DEFAULT_PATH := "res://src/core/rules/data/isu_sov_2025_26.json" const DEFAULT_PATH := "res://src/core/rules/data/isu_sov_2026_27.json"
const SUPPORTED_SCHEMA_VERSION := 1 const SUPPORTED_SCHEMA_VERSION := 1
const TYPE_BY_NAME := { const TYPE_BY_NAME := {

View file

@ -9,7 +9,7 @@ extends RefCounted
## only once per program, maximum features per foot) are stored in the data but ## only once per program, maximum features per foot) are stored in the data but
## not enforced here yet. ## not enforced here yet.
const DEFAULT_PATH := "res://src/core/rules/data/isu_levels_2025_26.json" const DEFAULT_PATH := "res://src/core/rules/data/isu_levels_2026_27.json"
const SUPPORTED_SCHEMA_VERSION := 1 const SUPPORTED_SCHEMA_VERSION := 1
const MAX_LEVEL := PathSegment.ELEMENT_MAX_LEVEL const MAX_LEVEL := PathSegment.ELEMENT_MAX_LEVEL
@ -19,6 +19,11 @@ const TYPE_BY_NAME := {
"sequence": PathSegment.ElementType.SEQUENCE, "sequence": PathSegment.ElementType.SEQUENCE,
} }
const FIXED_LEVEL_TYPES := {
"chsq": PathSegment.ElementType.SEQUENCE,
"chsp": PathSegment.ElementType.SPIN,
}
## Result of evaluating one element's selected features. ## Result of evaluating one element's selected features.
class LevelResult extends RefCounted: class LevelResult extends RefCounted:
var level: int = 0 var level: int = 0
@ -86,13 +91,13 @@ func get_level4_features(type: PathSegment.ElementType) -> PackedStringArray:
return _level4_by_type[type].duplicate() return _level4_by_type[type].duplicate()
## Fixed level for elements that are not feature-based (ChSq), or -1. ## Fixed level for elements that are not feature-based (ChSq, ChSp), or -1.
func get_fixed_level(type: PathSegment.ElementType, code: String) -> int: func get_fixed_level(type: PathSegment.ElementType, code: String) -> int:
if type != PathSegment.ElementType.SEQUENCE:
return -1
var key := _normalize(code) var key := _normalize(code)
if not _fixed_levels.has(key): if not _fixed_levels.has(key):
return -1 return -1
if FIXED_LEVEL_TYPES.get(key, PathSegment.ElementType.NONE) != type:
return -1
return _fixed_levels[key] return _fixed_levels[key]
@ -113,7 +118,7 @@ func calculate_level(
var result := LevelResult.new() var result := LevelResult.new()
var key := _normalize(code) var key := _normalize(code)
if _fixed_levels.has(key): if _fixed_levels.has(key):
if type == PathSegment.ElementType.SEQUENCE: if FIXED_LEVEL_TYPES.get(key, PathSegment.ElementType.NONE) == type:
result.level = _fixed_levels[key] result.level = _fixed_levels[key]
return result return result

View file

@ -8,11 +8,17 @@ extends RefCounted
var _catalog: ElementCatalog var _catalog: ElementCatalog
var _rules: ElementLevelRules var _rules: ElementLevelRules
var _adult_rules: AdultCategoryRules
func _init(catalog: ElementCatalog, rules: ElementLevelRules) -> void: func _init(
catalog: ElementCatalog,
rules: ElementLevelRules,
adult_rules: AdultCategoryRules = null
) -> void:
_catalog = catalog _catalog = catalog
_rules = rules _rules = rules
_adult_rules = adult_rules
## Returns the findings only. Use [method validate_report] when the UI also ## Returns the findings only. Use [method validate_report] when the UI also
@ -52,6 +58,7 @@ func validate_report(routine: Routine) -> ValidationReport:
_collect_program_features(segment, section.section_id, seen_once, report) _collect_program_features(segment, section.section_id, seen_once, report)
_collect_base_value(segment, section.section_id, report) _collect_base_value(segment, section.section_id, report)
_validate_category(routine, report)
return report return report
@ -79,6 +86,207 @@ func _collect_base_value(
report.scored_elements += 1 report.scored_elements += 1
func _validate_category(
routine: Routine,
report: ValidationReport
) -> void:
var category_code := routine.adult_category.strip_edges()
if category_code.is_empty() or _adult_rules == null:
return
var category := _adult_rules.get_category(category_code)
if category == null:
_add(
report,
"category",
ValidationIssue.Severity.ERROR,
"Unbekannte Adult-Kategorie „%s“." % category_code
)
return
_pass(report, "category")
var jumps := 0
var spins := 0
var step_sequences := 0
var choreographic_sequences := 0
var choreographic_spins := 0
var axel_present := false
var jump_type_failed := false
var level_failed := false
for section: RoutineSection in routine.sections:
if section == null:
continue
for segment: PathSegment in section.segments:
if segment == null or not segment.is_element():
continue
var code := segment.element_code.strip_edges()
var lower := code.to_lower()
match segment.element_type:
PathSegment.ElementType.JUMP:
jumps += 1
if AdultCategoryRules.Category.jump_type(code) == "A":
axel_present = true
if not category.is_jump_allowed(code):
_append(
report,
ValidationIssue.Severity.WARNING,
"„%s“ ist in %s nicht erlaubt."
% [code, category.name],
section.section_id,
segment.segment_id
)
jump_type_failed = true
PathSegment.ElementType.SPIN:
spins += 1
if lower.begins_with("chsp"):
choreographic_spins += 1
if segment.element_level > category.max_spin_level:
_append(
report,
ValidationIssue.Severity.WARNING,
"„%s“ hat Level %d; %s erlaubt bei Pirouetten max. Level %d."
% [
code,
segment.element_level,
category.name,
category.max_spin_level,
],
section.section_id,
segment.segment_id
)
level_failed = true
PathSegment.ElementType.SEQUENCE:
if lower.begins_with("chsq"):
choreographic_sequences += 1
else:
step_sequences += 1
if segment.element_level > category.max_sequence_level:
_append(
report,
ValidationIssue.Severity.WARNING,
"„%s“ hat Level %d; %s erlaubt bei Sequenzen max. Level %d."
% [
code,
segment.element_level,
category.name,
category.max_sequence_level,
],
section.section_id,
segment.segment_id
)
level_failed = true
_check_category_count(
report,
"category_jumps",
jumps,
category.max_jump_elements,
"Sprungelemente",
category.name
)
_check_category_count(
report,
"category_spins",
spins,
category.max_spins,
"Pirouetten",
category.name
)
var sequence_failed := false
if step_sequences > category.max_step_sequences:
_append(
report,
ValidationIssue.Severity.WARNING,
"Schrittsequenzen: %d, erlaubt sind max. %d (%s)."
% [step_sequences, category.max_step_sequences, category.name]
)
sequence_failed = true
if choreographic_sequences > category.max_choreographic_sequences:
_append(
report,
ValidationIssue.Severity.WARNING,
"Choreo-Sequenzen: %d, erlaubt sind max. %d (%s)."
% [
choreographic_sequences,
category.max_choreographic_sequences,
category.name,
]
)
sequence_failed = true
if sequence_failed:
_fail(report, "category_sequences", false)
else:
_pass(report, "category_sequences")
if jump_type_failed:
_fail(report, "category_jump_types", false)
else:
_pass(report, "category_jump_types")
if spins > 0 or step_sequences > 0 or choreographic_sequences > 0:
if level_failed:
_fail(report, "category_levels", false)
else:
_pass(report, "category_levels")
var required_failed := false
if category.required_axel and not axel_present:
_append(
report,
ValidationIssue.Severity.WARNING,
"%s verlangt einen Axel-Sprung." % category.name
)
required_failed = true
if category.requires_choreographic_spin and choreographic_spins == 0:
_append(
report,
ValidationIssue.Severity.WARNING,
"%s verlangt eine Choreographic Spin (ChSp)." % category.name
)
required_failed = true
if step_sequences < category.required_step_sequences:
_append(
report,
ValidationIssue.Severity.WARNING,
"%s verlangt mindestens %d Schrittsequenz(en)."
% [category.name, category.required_step_sequences]
)
required_failed = true
if choreographic_sequences < category.required_choreographic_sequences:
_append(
report,
ValidationIssue.Severity.WARNING,
"%s verlangt mindestens %d Choreo-Sequenz(en)."
% [category.name, category.required_choreographic_sequences]
)
required_failed = true
if required_failed:
_fail(report, "category_required", false)
else:
_pass(report, "category_required")
func _check_category_count(
report: ValidationReport,
check_code: String,
count: int,
maximum: int,
label: String,
category_name: String
) -> void:
if count > maximum:
_append(
report,
ValidationIssue.Severity.WARNING,
"%s: %d, erlaubt sind max. %d (%s)."
% [label, count, maximum, category_name]
)
_fail(report, check_code, false)
else:
_pass(report, check_code)
func _validate_segment( func _validate_segment(
segment: PathSegment, segment: PathSegment,
section_id: String, section_id: String,

View file

@ -13,6 +13,13 @@ const CHECK_ORDER := [
"required", "required",
"level_features", "level_features",
"once", "once",
"category",
"category_jumps",
"category_jump_types",
"category_spins",
"category_sequences",
"category_levels",
"category_required",
] ]
const CHECK_LABELS := { const CHECK_LABELS := {
@ -24,6 +31,13 @@ const CHECK_LABELS := {
"required": "Pflichtfeatures", "required": "Pflichtfeatures",
"level_features": "Level aus Features", "level_features": "Level aus Features",
"once": "Einmal pro Programm", "once": "Einmal pro Programm",
"category": "Kategorie",
"category_jumps": "Kategorie: Sprunganzahl",
"category_jump_types": "Kategorie: erlaubte Sprünge",
"category_spins": "Kategorie: Pirouetten",
"category_sequences": "Kategorie: Sequenzen",
"category_levels": "Kategorie: Level-Grenzen",
"category_required": "Kategorie: Pflichtelemente",
} }
var issues: Array[ValidationIssue] = [] var issues: Array[ValidationIssue] = []

View file

@ -52,6 +52,7 @@ 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 ELEMENT_LEVEL_RULES_SCRIPT := preload("res://src/core/rules/element_level_rules.gd")
const ROUTINE_VALIDATOR_SCRIPT := preload("res://src/core/rules/routine_validator.gd") const ROUTINE_VALIDATOR_SCRIPT := preload("res://src/core/rules/routine_validator.gd")
const ADULT_CATEGORY_RULES_SCRIPT := preload("res://src/core/rules/adult_category_rules.gd")
const FEATURE_MENU_RESET_ID := 1000000 const FEATURE_MENU_RESET_ID := 1000000
const CODE_OPTION_PLACEHOLDER_ID := 0 const CODE_OPTION_PLACEHOLDER_ID := 0
const CODE_OPTION_FREE_ID := 1000000 const CODE_OPTION_FREE_ID := 1000000
@ -121,6 +122,7 @@ const COMPACT_LAYOUT_WIDTH := 1280.0
@onready var element_feature_hint: Label = %ElementFeatureHint @onready var element_feature_hint: Label = %ElementFeatureHint
@onready var element_feature_menu: PopupMenu = %ElementFeatureMenu @onready var element_feature_menu: PopupMenu = %ElementFeatureMenu
@onready var validation_button: Button = %ValidationButton @onready var validation_button: Button = %ValidationButton
@onready var adult_category_option: OptionButton = %AdultCategoryOption
@onready var validation_dialog: AcceptDialog = %ValidationDialog @onready var validation_dialog: AcceptDialog = %ValidationDialog
@onready var validation_text: RichTextLabel = %ValidationText @onready var validation_text: RichTextLabel = %ValidationText
@onready var element_duration_spin: SpinBox = %ElementDurationSpin @onready var element_duration_spin: SpinBox = %ElementDurationSpin
@ -165,6 +167,7 @@ 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 _level_rules: ElementLevelRules
var _adult_rules: AdultCategoryRules
var _dialog_features: PackedStringArray = PackedStringArray() var _dialog_features: PackedStringArray = PackedStringArray()
var _show_score_info: bool = false var _show_score_info: bool = false
var _preset_speed: float = DEFAULT_SPEED_MPS var _preset_speed: float = DEFAULT_SPEED_MPS
@ -202,6 +205,11 @@ func _ready() -> void:
push_warning( push_warning(
"Level rules: %s" % ", ".join(_level_rules.get_errors()) "Level rules: %s" % ", ".join(_level_rules.get_errors())
) )
_adult_rules = ADULT_CATEGORY_RULES_SCRIPT.load_default()
if not _adult_rules.get_errors().is_empty():
push_warning(
"Adult categories: %s" % ", ".join(_adult_rules.get_errors())
)
validation_button.tooltip_text = ( validation_button.tooltip_text = (
"Prüft Kürzel, Elementtyp, Level, Features und Einmal-Regeln (Saison %s)" "Prüft Kürzel, Elementtyp, Level, Features und Einmal-Regeln (Saison %s)"
% _element_catalog.season % _element_catalog.season
@ -211,6 +219,7 @@ func _ready() -> void:
_setup_playback_controls() _setup_playback_controls()
_setup_timing_controls() _setup_timing_controls()
_setup_element_controls() _setup_element_controls()
_setup_adult_category_controls()
_setup_export_controls() _setup_export_controls()
labels_toggle.set_pressed_no_signal(rink_canvas.labels_visible) labels_toggle.set_pressed_no_signal(rink_canvas.labels_visible)
@ -443,7 +452,8 @@ func get_level_rules() -> ElementLevelRules:
func validate_routine() -> Array[ValidationIssue]: func validate_routine() -> Array[ValidationIssue]:
var validator: RoutineValidator = ROUTINE_VALIDATOR_SCRIPT.new( var validator: RoutineValidator = ROUTINE_VALIDATOR_SCRIPT.new(
_element_catalog, _element_catalog,
_level_rules _level_rules,
_adult_rules
) )
return validator.validate(_routine) return validator.validate(_routine)
@ -458,7 +468,8 @@ func open_validation_dialog() -> void:
func _render_validation_dialog() -> void: func _render_validation_dialog() -> void:
var validator: RoutineValidator = ROUTINE_VALIDATOR_SCRIPT.new( var validator: RoutineValidator = ROUTINE_VALIDATOR_SCRIPT.new(
_element_catalog, _element_catalog,
_level_rules _level_rules,
_adult_rules
) )
var report := validator.validate_report(_routine) var report := validator.validate_report(_routine)
var errors := RoutineValidator.count_severity( var errors := RoutineValidator.count_severity(
@ -482,6 +493,20 @@ func _render_validation_dialog() -> void:
season, season,
] ]
) )
var category_name := "Ohne Kategorie"
if (
_routine != null
and not _routine.adult_category.is_empty()
and _adult_rules != null
):
var category := _adult_rules.get_category(_routine.adult_category)
if category != null:
category_name = "%s · %s ±%d s" % [
category.name,
_format_duration(category.duration_seconds),
category.duration_tolerance_seconds,
]
lines.append("[b]Kategorie: %s[/b]" % category_name)
lines.append("") lines.append("")
lines.append( lines.append(
"[b]Basiswert: %s[/b]" % _format_base_value(report.base_value_total) "[b]Basiswert: %s[/b]" % _format_base_value(report.base_value_total)
@ -614,6 +639,8 @@ func _validation_check_line(check: ValidationCheck) -> String:
func _validation_skip_reason(check_code: String) -> String: func _validation_skip_reason(check_code: String) -> String:
if check_code.begins_with("category"):
return "keine Kategorie oder keine passenden Elemente"
match check_code: match check_code:
"code": "code":
return "keine Elemente" return "keine Elemente"
@ -680,6 +707,10 @@ static func _format_base_value(value: float) -> String:
return ("%.2f" % value).replace(".", ",") return ("%.2f" % value).replace(".", ",")
static func _format_duration(seconds: int) -> String:
return "%d:%02d" % [seconds / 60, seconds % 60]
func _on_validation_meta_clicked(meta: Variant) -> void: func _on_validation_meta_clicked(meta: Variant) -> void:
if str(meta) != "score_info": if str(meta) != "score_info":
return return
@ -1343,6 +1374,62 @@ func _setup_element_controls() -> void:
element_feature_menu.popup_hide.connect(_on_feature_menu_hidden) element_feature_menu.popup_hide.connect(_on_feature_menu_hidden)
func _setup_adult_category_controls() -> void:
adult_category_option.clear()
adult_category_option.add_item("Ohne Kategorie", 0)
adult_category_option.set_item_metadata(0, "")
if _adult_rules != null:
for category: AdultCategoryRules.Category in _adult_rules.get_categories():
var index := adult_category_option.item_count
adult_category_option.add_item(category.name, index)
adult_category_option.set_item_metadata(index, category.code)
adult_category_option.item_selected.connect(_on_adult_category_selected)
_sync_adult_category_option()
func _on_adult_category_selected(index: int) -> void:
set_adult_category(str(adult_category_option.get_item_metadata(index)))
func set_adult_category(code: String) -> bool:
if _routine == null:
return false
var cleaned := code.strip_edges().to_lower()
if (
not cleaned.is_empty()
and (_adult_rules == null or not _adult_rules.has_category(cleaned))
):
return false
if _routine.adult_category == cleaned:
return false
_record_undo()
_routine.adult_category = cleaned
_sync_adult_category_option()
_mark_dirty()
_update_status()
return true
func get_adult_category() -> String:
return _routine.adult_category if _routine != null else ""
func get_adult_rules() -> AdultCategoryRules:
return _adult_rules
func _sync_adult_category_option() -> void:
if adult_category_option == null:
return
var code := _routine.adult_category if _routine != null else ""
for index: int in range(adult_category_option.item_count):
if str(adult_category_option.get_item_metadata(index)) == code:
adult_category_option.select(index)
return
if adult_category_option.item_count > 0:
adult_category_option.select(0)
func _on_element_code_text_changed(_text: String) -> void: func _on_element_code_text_changed(_text: String) -> void:
_update_level_control_state() _update_level_control_state()
update_element_feature_hint() update_element_feature_hint()
@ -1634,6 +1721,7 @@ func _clone_routine(source: Routine) -> Routine:
clone.routine_id = source.routine_id clone.routine_id = source.routine_id
clone.title = source.title clone.title = source.title
clone.skater_name = source.skater_name clone.skater_name = source.skater_name
clone.adult_category = source.adult_category
if source.rink != null: if source.rink != null:
clone.rink = _clone_rink(source.rink) clone.rink = _clone_rink(source.rink)
@ -2696,6 +2784,7 @@ func _install_routine(
_routine = routine _routine = routine
if _routine.rink == null or not _routine.rink.is_valid(): if _routine.rink == null or not _routine.rink.is_valid():
_routine.rink = RinkDimensions.new() _routine.rink = RinkDimensions.new()
_sync_adult_category_option()
var valid_sections: Array[RoutineSection] = [] var valid_sections: Array[RoutineSection] = []
for section: RoutineSection in _routine.sections: for section: RoutineSection in _routine.sections:

View file

@ -30,6 +30,9 @@ $GODOT --headless --path rinkplanner --script res://tests/run_level_tests.gd
# Run routine element-validation tests # Run routine element-validation tests
$GODOT --headless --path rinkplanner --script res://tests/run_validation_tests.gd $GODOT --headless --path rinkplanner --script res://tests/run_validation_tests.gd
# Run adult category tests
$GODOT --headless --path rinkplanner --script res://tests/run_adult_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

@ -91,6 +91,9 @@ func _capture() -> void:
controller.element_button.pressed.emit() controller.element_button.pressed.emit()
elif args.size() > 3 and args[3] == "validate": elif args.size() > 3 and args[3] == "validate":
controller.open_validation_dialog() controller.open_validation_dialog()
elif args.size() > 3 and args[3] == "adultgold":
controller.set_adult_category("gold")
controller.open_validation_dialog()
elif args.size() > 3 and args[3] == "scoreinfo": elif args.size() > 3 and args[3] == "scoreinfo":
controller.open_validation_dialog() controller.open_validation_dialog()
controller.validation_text.meta_clicked.emit("score_info") controller.validation_text.meta_clicked.emit("score_info")

View file

@ -0,0 +1,274 @@
extends SceneTree
## Headless tests for the 2026/27 adult category rules and their validation.
##
## Run with:
## godot --headless --path rinkplanner --script res://tests/run_adult_tests.gd
const ElementCatalogScript := preload("res://src/core/rules/element_catalog.gd")
const ElementLevelRulesScript := preload("res://src/core/rules/element_level_rules.gd")
const AdultCategoryRulesScript := preload("res://src/core/rules/adult_category_rules.gd")
const RoutineValidatorScript := preload("res://src/core/rules/routine_validator.gd")
const RoutineModel := preload("res://src/core/model/routine.gd")
const RoutineSectionModel := preload("res://src/core/model/routine_section.gd")
const PathSegmentModel := preload("res://src/core/model/path_segment.gd")
var _assertions: int = 0
var _failures: PackedStringArray = PackedStringArray()
var _catalog: ElementCatalog
var _rules: ElementLevelRules
var _adult: AdultCategoryRules
var _validator: RoutineValidator
func _init() -> void:
_catalog = ElementCatalogScript.load_default()
_rules = ElementLevelRulesScript.load_default()
_adult = AdultCategoryRulesScript.load_default()
_validator = RoutineValidatorScript.new(_catalog, _rules, _adult)
_test_metadata()
_test_category_fields()
_test_jump_permissions()
_test_gold_limits()
_test_valid_gold()
_test_unknown_category()
_finish()
func _test_metadata() -> void:
_check(_adult.is_valid(), "adult rules are valid")
_check(_adult.season == "2026/27", "adult rules season is 2026/27")
_check(_adult.source.contains("Adult"), "adult rules name the adult announcement")
_check(
_adult.get_categories().size() == 5,
"five adult categories are available"
)
_check(_adult.has_category("gold"), "Gold category exists")
_check(_adult.has_category("silver"), "Silver category exists")
_check(_adult.has_category("bronze"), "Bronze category exists")
func _test_category_fields() -> void:
var gold := _adult.get_category("gold")
_check(gold.duration_seconds == 170, "Gold lasts 2:50")
_check(gold.max_jump_elements == 5, "Gold allows five jump elements")
_check(gold.max_spins == 3, "Gold allows three spins")
_check(gold.max_step_sequences == 1, "Gold allows one step sequence")
_check(gold.max_choreographic_sequences == 0, "Gold has no choreo sequence")
_check(gold.requires_choreographic_spin, "Gold requires a choreographic spin")
_check(gold.max_spin_level == 3, "Gold caps spins at Level 3")
_check(gold.max_sequence_level == 2, "Gold caps sequences at Level 2")
_check_approx(gold.pcs_factor, 2.67, "Gold PCS factor")
_check_approx(gold.fall_deduction, 1.0, "Gold fall deduction")
var silver := _adult.get_category("silver")
_check(silver.duration_seconds == 120, "Silver lasts 2:00")
_check(silver.max_spins == 2, "Silver allows two spins")
_check(silver.max_choreographic_sequences == 1, "Silver uses a choreo sequence")
_check(not silver.requires_choreographic_spin, "Silver needs no choreo spin")
_check(silver.max_spin_level == 2, "Silver caps spins at Level 2")
_check_approx(silver.pcs_factor, 2.0, "Silver PCS factor")
var bronze := _adult.get_category("bronze")
_check(bronze.duration_seconds == 100, "Bronze lasts 1:40")
_check(not bronze.allow_axel, "Bronze forbids Axel jumps")
_check(bronze.max_jump_combinations == 1, "Bronze allows one jump combination")
_check(bronze.max_spin_level == 1, "Bronze caps spins at Level 1")
func _test_jump_permissions() -> void:
var bronze := _adult.get_category("bronze")
_check(bronze.is_jump_allowed("1T"), "Bronze allows 1T")
_check(not bronze.is_jump_allowed("1A"), "Bronze forbids 1A")
_check(not bronze.is_jump_allowed("2T"), "Bronze forbids doubles")
var silver := _adult.get_category("silver")
_check(silver.is_jump_allowed("1A"), "Silver allows 1A")
_check(not silver.is_jump_allowed("2T"), "Silver forbids doubles")
var gold := _adult.get_category("gold")
_check(gold.is_jump_allowed("1A"), "Gold allows 1A")
_check(gold.is_jump_allowed("2T"), "Gold allows 2T")
_check(not gold.is_jump_allowed("2Lz"), "Gold forbids 2Lz")
_check(not gold.is_jump_allowed("2A"), "Gold forbids 2A")
_check(not gold.is_jump_allowed("3T"), "Gold forbids triples")
var masters := _adult.get_category("masters")
_check(masters.is_jump_allowed("2A"), "Masters allows 2A")
_check(not masters.is_jump_allowed("3T"), "Masters forbids triples")
var elite := _adult.get_category("masters_elite")
_check(elite.is_jump_allowed("3T"), "Masters Elite allows triples")
_check(not elite.is_jump_allowed("4T"), "Masters Elite forbids quads")
func _test_gold_limits() -> void:
var routine := _make_routine("gold")
var section := routine.sections[0]
for code: String in ["1T", "1S", "1Lo", "2T", "2S", "3T"]:
_add_jump(section, code)
for index: int in range(4):
_add_spin(section, "spin-%d" % index, "CCoSp", 4)
_add_sequence(section, "step", "StSq", 3)
var report := _validator.validate_report(routine)
_check(
report.get_check("category").passed == 1,
"the category itself is recognised"
)
_check(
report.get_check("category_jumps").warnings == 1,
"six jumps exceed the Gold limit"
)
_check(
report.get_check("category_jump_types").warnings == 1,
"3T is not allowed in Gold"
)
_check(
report.get_check("category_spins").warnings == 1,
"four spins exceed the Gold limit"
)
_check(
report.get_check("category_levels").warnings == 1,
"Level 4 exceeds the Gold level caps"
)
_check(
report.get_check("category_required").warnings == 1,
"the missing choreographic spin is reported"
)
_check(_has_message(report, "Sprungelemente: 6"), "jump count message")
_check(_has_message(report, "„3T“ ist in Gold nicht erlaubt"), "forbidden jump message")
_check(_has_message(report, "Pirouetten: 4"), "spin count message")
_check(_has_message(report, "max. Level 3"), "spin level cap message")
_check(_has_message(report, "Choreographic Spin"), "choreo spin message")
func _test_valid_gold() -> void:
var routine := _make_routine("gold")
var section := routine.sections[0]
for code: String in ["1A", "2T", "2S"]:
_add_jump(section, code)
_add_spin(section, "spin-a", "CCoSp", 3)
_add_spin(section, "spin-b", "FUSp", 3)
_add_spin(section, "spin-chsp", "ChSp", 1)
_add_sequence(section, "step", "StSq", 2)
var report := _validator.validate_report(routine)
_check(report.issues.is_empty(), "a valid Gold program has no findings")
_check(
report.get_check("category_jumps").passed == 1,
"the Gold jump count passes"
)
_check(
report.get_check("category_spins").passed == 1,
"the Gold spin count passes"
)
_check(
report.get_check("category_sequences").passed == 1,
"the Gold sequence count passes"
)
_check(
report.get_check("category_levels").passed == 1,
"the Gold level caps pass"
)
_check(
report.get_check("category_required").passed == 1,
"the Gold required elements pass"
)
func _test_unknown_category() -> void:
var routine := _make_routine("unknown")
var report := _validator.validate_report(routine)
_check(report.get_check("category").errors == 1, "an unknown category is an error")
_check(_has_message(report, "Unbekannte Adult-Kategorie"), "unknown category message")
func _make_routine(category: String) -> Routine:
var routine: Routine = RoutineModel.new()
routine.routine_id = "adult-test"
routine.title = "Adult"
routine.adult_category = category
var section: RoutineSection = RoutineSectionModel.new()
section.section_id = "section-001"
section.title = "Abschnitt 1"
section.sequence_order = 0
var sections: Array[RoutineSection] = [section]
routine.sections = sections
return routine
func _add_jump(section: RoutineSection, code: String) -> PathSegment:
var segment: PathSegment = PathSegmentModel.new()
segment.segment_id = "jump-%d" % section.segments.size()
segment.curve = _make_point_curve(Vector2.ZERO)
segment.set_element(PathSegment.ElementType.JUMP, code, 0)
section.segments.append(segment)
return segment
func _add_spin(
section: RoutineSection,
segment_id: String,
code: String,
level: int
) -> PathSegment:
var segment: PathSegment = PathSegmentModel.new()
segment.segment_id = segment_id
segment.curve = _make_point_curve(Vector2.ZERO)
segment.set_element(PathSegment.ElementType.SPIN, code, level)
section.segments.append(segment)
return segment
func _add_sequence(
section: RoutineSection,
segment_id: String,
code: String,
level: int
) -> PathSegment:
var segment: PathSegment = PathSegmentModel.new()
segment.segment_id = segment_id
segment.curve = _make_point_curve(Vector2.ZERO)
segment.set_element(PathSegment.ElementType.SEQUENCE, code, level)
section.segments.append(segment)
return segment
func _make_point_curve(point: Vector2) -> Curve2D:
var curve := Curve2D.new()
curve.add_point(point)
return curve
func _has_message(report: ValidationReport, fragment: String) -> bool:
for issue: ValidationIssue in report.issues:
if issue.message.contains(fragment):
return true
return false
func _check(condition: bool, message: String) -> void:
_assertions += 1
if not condition:
_failures.append(message)
func _check_approx(actual: float, expected: float, message: String) -> void:
_check(
absf(actual - expected) <= 0.001,
"%s (expected %.3f, got %.3f)" % [message, expected, actual]
)
func _finish() -> void:
if _failures.is_empty():
print("PASS: %d assertions" % _assertions)
quit(0)
return
for failure: String in _failures:
printerr("FAIL: %s" % failure)
printerr("%d of %d assertions failed" % [_failures.size(), _assertions])
quit(1)

View file

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

View file

@ -32,16 +32,16 @@ func _test_rules_metadata() -> void:
"level rules parse without errors (%s)" % ", ".join(_rules.get_errors()) "level rules parse without errors (%s)" % ", ".join(_rules.get_errors())
) )
_check(_rules.is_valid(), "level rules are valid") _check(_rules.is_valid(), "level rules are valid")
_check(_rules.season == "2025/26", "level rules season is 2025/26") _check(_rules.season == "2026/27", "level rules season is 2026/27")
_check(_rules.source.contains("2701"), "level rules name ISU communication 2701") _check(_rules.source.contains("2788"), "level rules name ISU communication 2788")
_check(_rules.valid_from == "2025-07-01", "level rules valid from 2025-07-01") _check(_rules.valid_from == "2026-06-01", "level rules valid from 2026-06-01")
_check( _check(
_rules.get_features(PathSegment.ElementType.SPIN).size() == 14, _rules.get_features(PathSegment.ElementType.SPIN).size() == 15,
"spin rules contain 14 features" "spin rules contain 15 features"
) )
_check( _check(
_rules.get_features(PathSegment.ElementType.SEQUENCE).size() == 4, _rules.get_features(PathSegment.ElementType.SEQUENCE).size() == 5,
"sequence rules contain 4 features" "sequence rules contain 5 features"
) )
_check( _check(
_rules.get_features(PathSegment.ElementType.JUMP).is_empty(), _rules.get_features(PathSegment.ElementType.JUMP).is_empty(),
@ -198,6 +198,22 @@ func _test_fixed_and_unlevelled_elements() -> void:
).level == 0, ).level == 0,
"a fixed level only applies to the matching element type" "a fixed level only applies to the matching element type"
) )
var chsp := _rules.calculate_level(
PathSegment.ElementType.SPIN,
"ChSp",
PackedStringArray()
)
_check(chsp.level == 1, "ChSp is fixed at Level 1")
var chsp_with_features := _rules.calculate_level(
PathSegment.ElementType.SPIN,
"ChSp1",
PackedStringArray(["difficult_exit"])
)
_check(chsp_with_features.level == 1, "ChSp ignores feature selections")
_check(
_rules.get_fixed_level(PathSegment.ElementType.SPIN, "ChSp") == 1,
"ChSp exposes its fixed level"
)
var jump := _rules.calculate_level( var jump := _rules.calculate_level(
PathSegment.ElementType.JUMP, PathSegment.ElementType.JUMP,
@ -254,10 +270,16 @@ func _test_feature_validation() -> void:
== PackedStringArray(["variety_of_turns"]), == PackedStringArray(["variety_of_turns"]),
"required sequence features are exposed" "required sequence features are exposed"
) )
var level4_features := _rules.get_level4_features(spins)
_check( _check(
_rules.get_level4_features(spins).size() == 6, level4_features.size() == 6,
"six spin features unlock Level 4" "six spin features unlock Level 4"
) )
_check(
level4_features.has("windmills")
and not level4_features.has("difficult_position_change"),
"the 2026/27 Level-4 list contains windmills instead of the position change"
)
func _test_segment_features() -> void: func _test_segment_features() -> void:

View file

@ -35,17 +35,17 @@ func _test_catalog_metadata() -> void:
"catalog parses without errors (%s)" % ", ".join(_catalog.get_errors()) "catalog parses without errors (%s)" % ", ".join(_catalog.get_errors())
) )
_check(_catalog.is_valid(), "catalog is valid") _check(_catalog.is_valid(), "catalog is valid")
_check(_catalog.season == "2025/26", "catalog season is 2025/26") _check(_catalog.season == "2026/27", "catalog season is 2026/27")
_check(_catalog.source.contains("2707"), "catalog names ISU communication 2707") _check(_catalog.source.contains("2786"), "catalog names ISU communication 2786")
_check(_catalog.valid_from == "2025-07-01", "catalog valid from 2025-07-01") _check(_catalog.valid_from == "2026-07-01", "catalog valid from 2026-07-01")
_check(_catalog.get_definition_count() == 42, "catalog has 42 element families") _check(_catalog.get_definition_count() == 43, "catalog has 43 element families")
_check( _check(
_catalog.get_codes(PathSegment.ElementType.JUMP).size() == 24, _catalog.get_codes(PathSegment.ElementType.JUMP).size() == 24,
"catalog has 24 jump families" "catalog has 24 jump families"
) )
_check( _check(
_catalog.get_codes(PathSegment.ElementType.SPIN).size() == 16, _catalog.get_codes(PathSegment.ElementType.SPIN).size() == 17,
"catalog has 16 spin families" "catalog has 17 spin families"
) )
_check( _check(
_catalog.get_codes(PathSegment.ElementType.SEQUENCE).size() == 2, _catalog.get_codes(PathSegment.ElementType.SEQUENCE).size() == 2,
@ -93,22 +93,37 @@ func _test_jump_values() -> void:
func _test_spin_values() -> void: func _test_spin_values() -> void:
_check_approx(_catalog.get_base_value("USpB"), 1.00, "USpB base value") _check_approx(_catalog.get_base_value("USpB"), 1.20, "USpB base value")
_check_approx(_catalog.get_base_value("USp4"), 2.40, "USp4 base value") _check_approx(_catalog.get_base_value("USp4"), 2.90, "USp4 base value")
_check_approx(_catalog.get_base_value("LSp4"), 2.70, "LSp4 base value") _check_approx(_catalog.get_base_value("LSp4"), 3.20, "LSp4 base value")
_check_approx(_catalog.get_base_value("FCSp4"), 3.20, "FCSp4 base value") _check_approx(_catalog.get_base_value("FCSp4"), 3.80, "FCSp4 base value")
_check_approx(_catalog.get_base_value("CCoSpB"), 1.70, "CCoSpB base value") _check_approx(_catalog.get_base_value("CCoSpB"), 2.00, "CCoSpB base value")
_check_approx(_catalog.get_base_value("CCoSp4"), 3.50, "CCoSp4 base value") _check_approx(_catalog.get_base_value("CCoSp4"), 4.20, "CCoSp4 base value")
_check_approx( _check_approx(
_catalog.get_base_value("CCoSp", 4), _catalog.get_base_value("CCoSp", 4),
3.50, 4.20,
"spin lookup by family and level" "spin lookup by family and level"
) )
_check_approx( _check_approx(
_catalog.get_base_value("CCoSp4", -1), _catalog.get_base_value("CCoSp4", -1),
3.50, 4.20,
"spin lookup infers the level suffix" "spin lookup infers the level suffix"
) )
_check_approx(
_catalog.get_base_value("ChSp1"),
3.50,
"ChSp1 base value"
)
var choreo_spin := _catalog.find("ChSp")
_check(
choreo_spin != null
and choreo_spin.element_type == PathSegment.ElementType.SPIN,
"ChSp is a spin family"
)
_check(
choreo_spin.get_codes() == PackedStringArray(["ChSp1"]),
"ChSp has only its fixed canonical level"
)
var combination: ElementDefinition = _catalog.find("CCoSp") var combination: ElementDefinition = _catalog.find("CCoSp")
_check(combination != null, "CCoSp family exists") _check(combination != null, "CCoSp family exists")
@ -129,12 +144,12 @@ func _test_spin_values() -> void:
func _test_sequence_values() -> void: func _test_sequence_values() -> void:
_check_approx(_catalog.get_base_value("StSqB"), 1.50, "StSqB base value") _check_approx(_catalog.get_base_value("StSqB"), 1.60, "StSqB base value")
_check_approx(_catalog.get_base_value("StSq3"), 3.30, "StSq3 base value") _check_approx(_catalog.get_base_value("StSq3"), 3.50, "StSq3 base value")
_check_approx(_catalog.get_base_value("ChSq1"), 3.00, "ChSq1 base value") _check_approx(_catalog.get_base_value("ChSq1"), 3.50, "ChSq1 base value")
_check_approx( _check_approx(
_catalog.get_base_value("ChSq"), _catalog.get_base_value("ChSq"),
3.00, 3.50,
"single-level sequence resolves without a suffix" "single-level sequence resolves without a suffix"
) )
_check_approx( _check_approx(
@ -170,17 +185,17 @@ func _test_lookup_rules() -> void:
) )
_check_approx( _check_approx(
_catalog.get_base_value("CCoSp4", 2), _catalog.get_base_value("CCoSp4", 2),
3.50, 4.20,
"a canonical suffix wins over the level argument" "a canonical suffix wins over the level argument"
) )
_check_approx( _check_approx(
_catalog.get_base_value("StSqB", 4), _catalog.get_base_value("StSqB", 4),
1.50, 1.60,
"a Base suffix wins over a graded level argument" "a Base suffix wins over a graded level argument"
) )
_check_approx( _check_approx(
_catalog.get_base_value("ChSq1", 0), _catalog.get_base_value("ChSq1", 0),
3.00, 3.50,
"an explicit sequence suffix wins over level 0" "an explicit sequence suffix wins over level 0"
) )
_check_approx( _check_approx(
@ -230,10 +245,20 @@ func _test_segment_integration() -> void:
spin.set_element(PathSegment.ElementType.SPIN, "CCoSp", 4) spin.set_element(PathSegment.ElementType.SPIN, "CCoSp", 4)
_check_approx( _check_approx(
_catalog.get_segment_base_value(spin), _catalog.get_segment_base_value(spin),
3.50, 4.20,
"segment integration resolves a spin" "segment integration resolves a spin"
) )
var choreo_spin: PathSegment = PathSegmentModel.new()
choreo_spin.segment_id = "choreo-spin"
choreo_spin.curve = _make_point_curve(Vector2.ZERO)
choreo_spin.set_element(PathSegment.ElementType.SPIN, "ChSp", 1)
_check_approx(
_catalog.get_segment_base_value(choreo_spin),
3.50,
"segment integration resolves a choreographic spin"
)
var jump: PathSegment = PathSegmentModel.new() var jump: PathSegment = PathSegmentModel.new()
jump.segment_id = "jump" jump.segment_id = "jump"
jump.curve = _make_point_curve(Vector2.ZERO) jump.curve = _make_point_curve(Vector2.ZERO)
@ -250,7 +275,7 @@ func _test_segment_integration() -> void:
sequence.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 3) sequence.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 3)
_check_approx( _check_approx(
_catalog.get_segment_base_value(sequence), _catalog.get_segment_base_value(sequence),
3.30, 3.50,
"segment integration resolves a sequence" "segment integration resolves a sequence"
) )

View file

@ -95,8 +95,8 @@ func _test_clean_routine() -> void:
_check(report.get_check("once").passed == 6, "once-per-program features were checked") _check(report.get_check("once").passed == 6, "once-per-program features were checked")
_check_approx( _check_approx(
report.base_value_total, report.base_value_total,
7.40, 8.30,
"the report sums the base values (3.50 + 3.90)" "the report sums the base values (4.20 + 4.10)"
) )
_check(report.scored_elements == 2, "both elements were scored") _check(report.scored_elements == 2, "both elements were scored")
_check(report.unscored_elements == 0, "no element is unscored") _check(report.unscored_elements == 0, "no element is unscored")
@ -228,7 +228,7 @@ func _test_fixed_level() -> void:
) )
_check(valid.issues.is_empty(), "ChSq at Level 1 is valid") _check(valid.issues.is_empty(), "ChSq at Level 1 is valid")
_check(valid.get_check("fixed_level").passed == 1, "the fixed-level check passes") _check(valid.get_check("fixed_level").passed == 1, "the fixed-level check passes")
_check_approx(valid.base_value_total, 3.00, "ChSq contributes 3.00") _check_approx(valid.base_value_total, 3.50, "ChSq contributes 3.50")
func _test_missing_code() -> void: func _test_missing_code() -> void:

View file

@ -799,9 +799,9 @@ func _run() -> void:
"the level is read-only for a catalog spin" "the level is read-only for a catalog spin"
) )
var catalog := controller.get_element_catalog() var catalog := controller.get_element_catalog()
_check(catalog != null and catalog.season == "2025/26", "controller loads the ISU catalog") _check(catalog != null and catalog.season == "2026/27", "controller loads the ISU catalog")
_check( _check(
controller.element_value_label.text.contains("3,50"), controller.element_value_label.text.contains("4,20"),
"element dialog shows the base value of the current code and level" "element dialog shows the base value of the current code and level"
) )
@ -820,7 +820,7 @@ func _run() -> void:
) )
controller.update_element_value_hint() controller.update_element_value_hint()
_check( _check(
controller.element_value_label.text.contains("2,50"), controller.element_value_label.text.contains("3,00"),
"base value follows the derived level 2" "base value follows the derived level 2"
) )
@ -830,7 +830,7 @@ func _run() -> void:
"free-text mode shows the text field" "free-text mode shows the text field"
) )
_check( _check(
controller.element_value_label.text.contains("3,50"), controller.element_value_label.text.contains("4,20"),
"a canonical suffix wins over the derived level" "a canonical suffix wins over the derived level"
) )
@ -864,8 +864,8 @@ func _run() -> void:
"feature menu populates for a spin" "feature menu populates for a spin"
) )
_check( _check(
controller.element_feature_menu.item_count == 17, controller.element_feature_menu.item_count == 18,
"feature menu lists 14 features plus the second difficult variation" "feature menu lists 15 features plus the second difficult variation"
) )
_check( _check(
controller.element_feature_menu.get_item_metadata(0) == "difficult_variation", controller.element_feature_menu.get_item_metadata(0) == "difficult_variation",
@ -1249,7 +1249,7 @@ func _run() -> void:
) )
_check( _check(
controller.validation_text.text.contains("Geprüft: 1 Element in 1 Abschnitt") controller.validation_text.text.contains("Geprüft: 1 Element in 1 Abschnitt")
and controller.validation_text.text.contains("Saison 2025/26"), and controller.validation_text.text.contains("Saison 2026/27"),
"validation dialog states the scope of the check" "validation dialog states the scope of the check"
) )
_check( _check(
@ -1323,11 +1323,53 @@ func _run() -> void:
) )
_check( _check(
controller.validation_text.text.contains("Basiswert") controller.validation_text.text.contains("Basiswert")
and controller.validation_text.text.contains("1,70"), and controller.validation_text.text.contains("2,00"),
"clean validation shows the base value of a Base spin" "clean validation shows the base value of a Base spin"
) )
controller.validation_dialog.hide() controller.validation_dialog.hide()
# Adult category validation.
controller.new_routine()
_check(controller.set_adult_category("gold"), "Gold category can be selected")
_check(controller.get_adult_category() == "gold", "the routine stores the category")
var selected_category := controller.adult_category_option.selected
_check(
str(controller.adult_category_option.get_item_metadata(selected_category))
== "gold",
"the category dropdown reflects the routine"
)
for code: String in ["1T", "1S", "1Lo", "2T", "2S", "3T"]:
controller.add_element_marker(
Vector2(0.0, 0.0),
PathSegment.ElementType.JUMP,
code,
0
)
var category_issues := controller.validate_routine()
_check(
category_issues.size() >= 3,
"the Gold category reports count, jump-type and required-element findings"
)
controller.open_validation_dialog()
_check(
controller.validation_text.text.contains("Kategorie: Gold"),
"validation dialog names the adult category"
)
_check(
controller.validation_text.text.contains("Sprungelemente: 6"),
"validation dialog reports the jump count"
)
_check(
controller.validation_text.text.contains("3T")
and controller.validation_text.text.contains("nicht erlaubt"),
"validation dialog reports a forbidden Gold jump"
)
_check(
controller.validation_text.text.contains("Choreographic Spin"),
"validation dialog reports the missing choreographic spin"
)
controller.validation_dialog.hide()
scene.queue_free() scene.queue_free()
await process_frame await process_frame
_finish() _finish()

View file

@ -31,6 +31,9 @@ fi
"$GODOT" --headless --path "$PROJECT_DIR" \ "$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/run_validation_tests.gd --script res://tests/run_validation_tests.gd
"$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/run_adult_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