feat: Regelwerk als Saisonordner mit Invariantenprüfung

Das ISU-Regelwerk liegt jetzt je Saison in einem eigenen Ordner mit
Manifest. Der Code fragt nach Dokumentarten (sov, levels, adult) statt nach
Dateinamen; eine neue Saison braucht kein GDScript.

- Manifest je Saison mit Quellen, valid_from und deklarativen Policies.
  Fehlt eine Policy, gilt sie in dieser Saison nicht – alte Saisons erben
  keine später erfundenen Regeln.
- RulesLibrary findet die Saisons per Verzeichnis-Scan, löst Vererbung für
  zeitversetzt erscheinende Papiere auf und wählt als Voreinstellung die
  neueste vollständige Saison ab valid_from.
- RulesAudit prüft den Invariantenkatalog A–F (Sprungreihenfolge, Level-
  Schwellen, Adult-Grenzen, Policies) und läuft über tools/check_rules.sh
  sowie in ./tools/test.sh.
- Saison an der Kür (Schema 7): alte Küren werden gegen das Regelwerk ihrer
  eigenen Saison geprüft. Die Statusleiste zeigt und wechselt die Saison;
  ohne Zuordnung prüft die App nichts, statt still gegen die falsche Saison
  zu rechnen.
- Validator läuft pro Regelpaket; ein Saison-Paar-Test sichert die
  dokumentierte Differenz zwischen 2025/26 und 2026/27 ab.
- PDF-Kopf nennt die Saison, docs/manual.md erklärt die Zuordnung,
  docs/isu-rules-structure.md beschreibt Struktur und Migrationsplan.

2025/26 hat noch keine Adult-Regeln; das Manifest markiert das Dokument
als missing, die Prüfung meldet die Kategorie als nicht anwendbar.
This commit is contained in:
torsten 2026-11-13 10:39:49 +01:00
parent e31e78d464
commit 386105aa71
40 changed files with 2716 additions and 77 deletions

536
docs/isu-rules-structure.md Normal file
View file

@ -0,0 +1,536 @@
# ISU-Regelwerk – Struktur, Pflege und Saisonwechsel
Stand: 2026-11-13
Status: **weitgehend umgesetzt.** Die Schritte 1–5 der Umsetzungsreihenfolge
stehen: Saisonordner, Manifest, Policies, Invariantenkatalog A–F, Saison an der
Kür, Validator pro Regelpaket, Oberfläche und Export folgen der Saison. Offen
sind die Saison-Upgrade-Prüfung (Schritt 6) und die Feature-Grenzen pro Fuß
(Schritt 7).
## Zweck
Zwei Anforderungen bestimmen alles Weitere:
1. **Pflege über Jahre:** Ein Saisonwechsel soll Datenarbeit sein, keine
Codearbeit. Wenn eine neue Saison GDScript berührt, ist die Struktur nicht
fertig.
2. **Alte Küren bleiben gültig:** Eine Kür wird **immer** gegen das Regelwerk
der Saison geprüft, in der sie gelaufen ist – nicht gegen das der App.
## Grundsätze
1. **Daten schlagen Code.** Alles, was sich jährlich ändert, ist JSON. Code
ändert sich nur bei einer strukturellen ISU-Reform, dann mit
`schema_version`.
2. **`kind` statt Dateiname.** Der Code fragt nach `sov`, `levels`, `adult`.
Dateinamen stehen ausschließlich im Manifest.
3. **Die Saison hängt an der Kür, nicht am Build.** Es gibt keine
„aktive Saison" als Konstante, sondern eine Auflösung pro Kür.
4. **Fehlt eine Policy, gilt sie nicht.** Saisonabhängige Prüfungen haben
keinen stillen Default im Code; sonst erben alte Saisons neue Regeln.
5. **Codes sind Verträge.** `element_code` und Feature-Codes werden in
Kürdateien gespeichert und nie umbenannt. Nur `name` und `description`
dürfen sich ändern.
6. **Kein Saisonordner wird gelöscht.** Ein Regelpaket kostet ~15 KB pro Jahr.
Git-Historie ersetzt keine ladbaren Daten.
7. **Prüfen ist nicht Umstellen.** Eine Kür wechselt die Saison nur auf
ausdrückliche Bestätigung; Prüfberichte ändern nie etwas.
8. **Keine Regel-Bearbeitung in der App.** Regeln liegen im Repo, versioniert
und im Diff reviewbar. Ein Editor wäre eine zweite Wahrheit.
## Verhältnis zu den anderen Dokumenten
| Dokument | Zielgruppe | Inhalt |
| :--- | :--- | :--- |
| `docs/isu-rules.md` | Anwender | Was in dieser Saison gilt (Katalog, Level, Adult) |
| `docs/isu-rules-structure.md` | Pflege | Wie die Daten aufgebaut sind und wie man sie fortschreibt |
| `docs/manual.md` | Anwender | Bedienung der App |
Die Anwender-Doku wird künftig aus den Daten erzeugt (Kategorie-Tabelle,
Elementzahlen), damit sie nicht driften kann. Bis dahin bleibt sie von Hand
gepflegt.
## Ordnerstruktur
```
rinkplanner/src/core/rules/
├── data/
│ ├── 2025-26/
│ │ ├── manifest.json
│ │ ├── sov.json
│ │ ├── levels.json
│ │ ├── adult.json
│ │ └── notes.md
│ └── 2026-27/
│ ├── manifest.json
│ ├── sov.json
│ ├── levels.json
│ ├── adult.json
│ └── notes.md
├── element_catalog.gd
├── element_level_rules.gd
└── adult_category_rules.gd
```
- Der Ordnername ist die Saison mit `-` statt `/`: `2026-27` ↔ `2026/27`.
Abweichung ist ein Fehler (A1).
- `notes.md` ist Pflicht und beschreibt, was sich gegenüber der Vorsaison
geändert hat (siehe E1–E3).
- Die bisherigen Dateien `isu_sov_2026_27.json` usw. entfallen nach der
Migration. Es gibt genau einen Satz Daten pro Saison; die Historie liegt in
Git.
## Manifest
Vollständige Saison:
```json
{
"schema_version": 1,
"season": "2026/27",
"label": "Saison 2026/27",
"valid_from": "2026-07-01",
"status": "complete",
"replaces": "2025/26",
"documents": {
"sov": {
"file": "sov.json",
"source": "ISU Communication No. 2786, Scale of Values …",
"valid_from": "2026-07-01"
},
"levels": {
"file": "levels.json",
"source": "ISU Communication No. 2788, Levels of Difficulty …",
"valid_from": "2026-06-01"
},
"adult": {
"file": "adult.json",
"source": "IAFSC Technical Announcement 2026/27",
"valid_from": "2026-07-01"
}
}
}
```
Unvollständige Saison (die Papiere kommen zeitversetzt):
```json
{
"schema_version": 1,
"season": "2027/28",
"valid_from": "2027-07-01",
"status": "partial",
"replaces": "2026/27",
"documents": {
"sov": { "file": "sov.json", "source": "ISU Communication No. 28xx …" },
"levels": { "inherit_from": "2026-27" },
"adult": { "inherit_from": "2026-27" }
}
}
```
Regeln:
- Ein Dokument-Eintrag hat **genau eines** von `file`, `inherit_from` oder
`status: missing` (A4).
- `status: complete` verbietet `inherit_from` (A6). Ein einzelnes fehlendes
Dokument macht die Saison **nicht** unvollständig: `2025/26` ist vollständig,
auch wenn das Adult-Announcement nicht erfasst ist. Der Mangel wird am
Dokument gemeldet und im Prüfdialog als „nicht anwendbar" sichtbar.
- `status: partial` heißt: Katalog oder Level-Regeln liegen nur geerbt vor.
Nur solche Saisons aktivieren sich nicht von selbst.
- Geerbte Dokumente bleiben im Bericht sichtbar: „Level-Regeln noch aus
2026/27 (Communication für 2027/28 fehlt)".
- `valid_from` der Teildateien darf sich unterscheiden – SoV und Levels werden
erfahrungsgemäß zu verschiedenen Terminen veröffentlicht. Sie müssen nur im
selben Saisonfenster liegen (A8).
### Korrekturen innerhalb einer Saison
Die ISU korrigiert gelegentlich mitten in der Saison. **Entschieden:** Die
Saison wird mutiert, es gibt keine Revisionen.
- Die betroffene Datei wird korrigiert, `valid_from` bleibt.
- `notes.md` bekommt eine Zeile: Datum, Communication, Änderung.
- Folge: Alle Küren dieser Saison werden ab sofort nach der korrigierten
Fassung geprüft, auch rückwirkend.
Das ist für ein Planungs- und Trainingswerkzeug richtig: Es gibt keine
amtliche Punktzahl, die rekonstruiert werden müsste. Zwei Revisionen in der
Oberfläche wären für einen Trainer nur verwirrend. Die Rückwirkung ist der
Preis und steht so in `notes.md`.
## Saisonauflösung
**Voreinstellung für neue Küren:** die Saison mit dem größten `valid_from`
≤ heute, die `status: complete` hat. Eine ausgelieferte Folgesaison schaltet
sich damit am 1. Juli von selbst scharf – ein Pflegeschritt weniger.
- Eine `partial`-Saison aktiviert sich **nie** von selbst.
- Ein Entwickler-Schalter muss eine Saison erzwingen können (Saisontest).
**Für eine bestehende Kür gilt immer die in der Datei gespeicherte Saison.**
Daraus folgen drei Zustände:
| Zustand | Beispiel | Verhalten |
| :--- | :--- | :--- |
| Saison mit Regeln | `2026/27` | vollständig prüfen; Inspector, Kategorie und Picker aus dieser Saison |
| Saison ohne Regeln | `2027/28` im Sommer geplant | zeichnen und speichern; Prüfung meldet „Regeln für 2027/28 liegen noch nicht vor" |
| Saison nicht festgelegt | Altdatei ohne Feld | Statusleiste zeigt „nicht festgelegt"; der Tooltip nennt die zum Dateidatum passende Saison. Geprüft wird erst nach der Auswahl |
Zwei Randfälle, die ausdrücklich so behandelt werden:
- **Kür neuer als die App:** Geometrie, Labels und Playback funktionieren;
Bearbeiten und Prüfen werden mit klarer Meldung verweigert. Nicht
„irgendwie gegen die neueste bekannte Saison prüfen" – das wäre eine stille
Falschaussage.
- **Kür ohne Saison wird nie stillschweigend zugeordnet.** Die Annahme der
aktuellen Saison würde eine Regelkonformität behaupten, die nicht geprüft
ist.
## Policies: deklarierte Prüfungen
Das ist der Kern der Mehrsaison-Fähigkeit. „Das damalige Regelwerk" steckt zu
etwa 95 % in den Daten und zu 5 % im Validator-Code. Daten lassen sich
einfrieren, Code nicht – er wird mit jeder App-Version besser. Deshalb müssen
saisonabhängige Prüfungen **von den Daten deklariert** werden.
```json
"policies": {
"axel_required_in_sequence": true,
"max_features_per_foot": null,
"feature_position_rules": false
}
```
Die Policies stehen im **Manifest** der Saison, nicht in den Teildateien: Sie
betreffen die Programmprüfung als Ganzes, nicht ein einzelnes Dokument.
Harte Semantik: **Fehlt ein Schlüssel, existiert die Regel in dieser Saison
nicht.** Kein Default, kein „im Zweifel an" (F1). Werte, die es nicht gibt,
werden daher weggelassen statt auf `null` gesetzt. Sonst erbt `2025/26`
automatisch jede Regel, die später erfunden wird, und die Mehrsaison-Fähigkeit
ist wertlos.
### Einordnung der heutigen Prüfungen
| Prüfung | Art | Ort |
| :--- | :--- | :--- |
| Kürzel im Katalog | strukturell, zeitlos | Code |
| Elementtyp passt | strukturell, zeitlos | Code |
| Level existiert / Sprung-Level 0 | strukturell | Code, Werte aus Daten |
| Level aus Features berechnen | Logik | Code |
| Feste Level (ChSq/ChSp) | Daten | `fixed_levels` |
| Pflichtfeatures | Daten | `required_features` |
| Max. Features pro Element | Daten | `max_per_element` |
| Einmal pro Programm | Daten | `once_per_program` |
| **Axel-Pflicht in Sprungfolge** | **Policy** | `policies.axel_required_in_sequence` |
| **Max. zwei Features pro Fuß** | **Policy** (geplant) | `policies.max_features_per_foot` |
| **Feature-Positionsregeln** | **Policy** (geplant) | `policies.feature_position_rules` |
| Adult-Grenzen | Daten | `adult.json` |
Die Axel-Pflicht steht heute im Code und gilt damit rückwirkend für jede
2025/26-Kür. Sie wandert bei der Migration in die Daten. Dasselbe gilt für
„max. zwei Features pro Fuß": Wenn sie als GDScript-Bedingung entsteht, ist
der nächste Saisonwechsel wieder Codearbeit.
**Strukturell zeitlos** bleibt alles, was für jede denkbare Saison gilt:
Kürzel muss existieren, Typ muss passen, Level muss im Datenbestand vorhanden
sein, das Level aus Features muss zum gespeicherten Level passen.
## Invarianten
Geprüft von `tools/check_rules.sh` (`RulesAudit`, eigenständig lauffähig, von
`./tools/test.sh` mit aufgerufen). **Fehler** blockiert, **Warnung** wird
gemeldet und ist durchlassbar.
Die Gruppen A–F sind implementiert; Ausnahmen sind bei der jeweiligen Zeile
vermerkt.
### A. Manifest und Ordner
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| A1 | Ordnername == `season` mit `-` statt `/` | Fehler |
| A2 | `schema_version` ist der App bekannt | Fehler |
| A3 | `sov`, `levels`, `adult` je genau einmal vorhanden | Fehler |
| A4 | Jeder Dokument-Eintrag hat genau eines von `file`, `inherit_from`, `status: missing` | Fehler |
| A5 | `file` existiert und ist gültiges JSON | Fehler |
| A6 | `status: complete` ⇒ kein `inherit_from`, und `sov`/`levels` liegen als Datei vor | Fehler |
| A7 | `season` im Manifest == `season` in jeder Teildatei | Fehler |
| A8 | `valid_from` ist ISO-Datum; alle Dokumente liegen im selben Saisonfenster (± 120 Tage) | Fehler |
| A9 | `inherit_from` existiert, ist älter und bildet keinen Zyklus | Fehler |
| A10 | `valid_from` größer als das der Vorsaison | Warnung |
| A11 | `replaces` verweist auf eine vorhandene Saison (oder `null` bei der ersten) | Fehler |
### B. Katalog (`sov`)
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| B1 | `code` eindeutig, nicht leer, ohne Leerzeichen | Fehler |
| B2 | `type` ∈ {`jump`, `spin`, `sequence`} | Fehler |
| B3 | `jump` ⇒ genau `base_value`; `spin`/`sequence` ⇒ genau `base_values` | Fehler |
| B4 | `base_values` enthält `"B"` und jedes Level aus `levels.levels` lückenlos | Fehler |
| B5 | Werte > 0, ≤ 2 Nachkommastellen, innerhalb 0,3 … 15,0 | Fehler |
| B6 | Sprungfamilien vollständig (1–4 × {T, S, Lo, F, Lz, A}); Lücken nur mit Begründung in `notes.md` | Warnung |
| B7 | Base Values nicht-fallend in der Reihenfolge T ≤ S ≤ Lo ≤ F ≤ Lz ≤ A | Fehler |
| B8 | Base Values streng steigend mit der Rotationszahl je Sprungart (`2Lz > 1Lz`) | Fehler |
| B9 | Pirouetten-/Sequenz-BV streng steigend über die Level (`B < 1 < 2 < 3 < 4`) | Fehler |
B7 und B8 sind die stärksten Prüfungen im Katalog: Sie fangen Zahlendreher
(`1,30` → `3,10`) ohne einen einzigen gepflegten Sollwert und gelten in jeder
Saison. B7 ist bewusst **nicht** streng, weil `1T` == `1S` und `1Lo` == `1F`
gilt.
B7 ist eine Annahme über die ISU, keine Tatsache. Bricht die ISU sie, braucht
die Prüfung eine begründete Ausnahmeliste – nicht das Abschalten der Prüfung.
### C. Level-Regeln (`levels`)
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| C1 | Jeder Code in `fixed_levels` existiert im Katalog | Fehler |
| C2 | Jeder Sprung hat **keinen** `types`-Eintrag; jeder Spin-/Sequenz-Code hat einen | Fehler |
| C3 | Feature-`code` je Typ eindeutig; `name` und `description` nicht leer | Fehler |
| C4 | `required_features` ⊆ Feature-Codes des Typs | Fehler |
| C5 | `level4_requires_any` ⊆ Feature-Codes des Typs | Fehler |
| C6 | `levels`: `min_features` streng steigend, beginnt bei 1, lückenlos | Fehler |
| C7 | Höchste `min_features` ≤ Anzahl Features des Typs (Level 4 erreichbar) | Fehler |
| C8 | Level in `levels` == Level in `base_values` aller levelbaren Elemente | Fehler |
| C9 | `max_per_element` ≥ 1; `once_per_program` ist Boolean | Fehler |
C2 ersetzt eine heute implizite Annahme: „Sprünge sind nicht levelbar". Bekäme
ein Sprung versehentlich einen `types`-Eintrag, rechnete die App plötzlich
Level für Sprünge. C7 fängt den typischen Fehler beim Features-Umbau: drei
Features definieren, aber Level 4 bei vier verlangen.
### D. Adult-Kategorien
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| D1 | `code` eindeutig, `name` nicht leer, `duration_seconds` 60–300 | Fehler |
| D2 | `forbidden_jumps` ⊆ Katalog-Codes vom Typ `jump` | Fehler |
| D3 | `allowed_rotations` ⊆ {`single`, `double`, `triple`, `quad`} | Fehler |
| D4 | `required_axel` ⇒ `allow_axel` | Fehler |
| D5 | `forbidden_jumps` enthält keinen Axel, wenn `allow_axel: true` | Warnung |
| D6 | `max_spin_level` / `max_sequence_level` ≤ höchstes Level der Saison | Fehler |
| D7 | `required_*` ≤ `max_*` (Schrittsequenz, Choreo-Sequenz) | Fehler |
| D8 | `max_jumps_per_combination` ≥ 2, sobald `max_jump_combinations` > 0 | Fehler |
| D9 | `requires_choreographic_spin` ⇒ `ChSp` existiert im Katalog | Fehler |
| D10 | `pcs_factor` > 0, `fall_deduction` ≥ 0 | Fehler |
| D11 | `max_jumps_per_combination` ≤ `max_jump_elements` | Fehler |
D5 ist absichtlich nur eine Warnung: In Gold stehen `2F`, `2Lz` und `2A` in
`forbidden_jumps`, während `allow_axel: true` gilt. Das ist kein Widerspruch –
verboten ist der *gesprungene* 2A, nicht der Axel an sich. Die Semantik von
`forbidden_jumps` („Element-Code, nicht Rotation") gehört als Kommentar in die
Datei, damit sie beim nächsten Pflegenden nicht anders gelesen wird.
### E. Über Saisons hinweg
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| E1 | Jeder gegenüber der Vorsaison verschwundene Code ist in `notes.md` erwähnt | Warnung |
| E2 | Jeder neue Code ist in `notes.md` erwähnt | Warnung |
| E3 | Jeder geänderte Wert steht als „alt → neu" in `notes.md` | manuell |
| E4 | In Kürdateien gespeicherte Codes (`element_code`, Feature-Codes) sind unverändert – oder über eine Alias-Tabelle auflösbar | Fehler |
| E5 | Alias-Ziele existieren; der Altcode kommt in keiner Saison mehr als aktiver Code vor | Fehler |
| E6 | Für jedes Saisonpaar existiert ein Test, der eine Referenzkür gegen beide Saisons prüft und die dokumentierte Differenz festnagelt | Warnung |
E4 ist die stille Falle: Eine Kür speichert `element_code` und
`element_features` als Strings. Wird `windmills` zu `windmill`, öffnen alte
Küren mit „unbekanntes Feature" – ohne Fehlermeldung, ohne Migration. Weil
alte Küren jetzt dauerhaft gültig bleiben, ist „Codes einfrieren" keine
Empfehlung mehr, sondern Vertrag. Eine Alias-Tabelle gibt es noch nicht; E4/E5
gelten derzeit durch die Konvention, dass Codes nie umbenannt werden.
E6 ist der einzige Test, der verhindert, dass alte Regeln später versehentlich
„mitrepariert" werden: Die Kür besteht 2025/26 und scheitert 2026/27 an genau
den zwei erwarteten Befunden.
### F. Policies
| ID | Prüfung | Schwere |
| :-- | :--- | :--- |
| F1 | Kein Policy-Wert hat einen stillen Default im Code; fehlt der Schlüssel, ist die Regel inaktiv | Fehler |
| F2 | Unbekannte Policy-Schlüssel in den Daten sind ein Fehler (Tippfehlerschutz) | Fehler |
| F3 | Policy-Werte haben den erwarteten Typ und Wertebereich | Fehler |
| F4 | Jede Saison deklariert dieselbe Policy-Menge – oder die Abweichung steht in `notes.md` | Warnung |
| F5 | Für jede Policy existiert ein Test, dass sie in einer Saison ohne den Schlüssel nicht wirkt | Warnung |
## Saison-Upgrade-Prüfung (geplantes Feature)
**Motivation:** Ein Verein stellt im Sommer auf die neue Saison um und muss
wissen, was an bestehenden Küren bricht. Heute gibt es dafür keine Antwort
außer „Kür öffnen und hoffen".
**Nutzen:** Das ist der eigentliche Grund, warum sich die Mehrsaison-Struktur
für den Anwender auszahlt – nicht das Archiv, sondern der Vergleich.
**Voraussetzung:** Der Validator ist eine reine Funktion über
(Kür, Regelpaket). Der Bericht ist dann die Differenz zweier Prüfläufe plus
ein Katalog-Diff. Deshalb ist das Feature „fast gratis", sobald die
Saison-Kontext-Umstellung steht – aber nicht vorher.
### Bedienung
- Auslöser im Prüfdialog und in der Statusleiste: **„Gegen Saison … prüfen"**
mit Auswahl der Ziel-Saison.
- Zwei getrennte Aktionen:
- **Nur prüfen** – schreibgeschützt, ändert nichts.
- **Auf Saison umstellen** – ausdrücklich bestätigt, ein Undo-Schritt,
ändert nur `season` an der Kür.
- Beim Umstellen werden **keine** Elementdaten stillschweigend angepasst. Ein
Kürzel, das es in der Ziel-Saison nicht mehr gibt, bleibt stehen und wird
als Befund gemeldet. Automatisches Löschen oder Umbenennen würde Arbeit
vernichten.
### Bericht
Vier Gruppen, jeder Befund mit Abschnitt und Segment verlinkt:
1. **Elemente:** nicht mehr im Katalog; Typ geändert; Level nicht mehr
verfügbar; Base Value geändert (alt → neu).
2. **Features:** in der Kür gesetzt, in der Ziel-Saison unbekannt; neues
Pflichtfeature; Level-Ergebnis ändert sich (L3 → L2).
3. **Kategorie:** Grenzen geändert (Dauer, Sprunganzahl, Level-Caps, erlaubte
Sprünge); Kategorie in der Ziel-Saison nicht vorhanden.
4. **Summe:** Punktschätzung alt vs. neu mit Differenz.
Zusätzlich nennt der Kopf beide Saisons und die Quelle, und er weist aus,
wenn sich das Prüfverhalten durch Policies ändert („Axel-Pflicht in
Sprungfolge: neu").
Beispielausgabe:
```
Kür „Kür 2026/27 Gold" — 2026/27 → 2027/28
Elemente
• 2 Elemente nicht mehr im Katalog: 2A (Abschnitt 2), CCoSp (Abschnitt 3)
• 3Lz Base Value 5,90 → 6,00
Features
• 1 Feature entfallen: windmills (nicht mehr in 2027/28)
• CCoSp: Level 3 → Level 2
Kategorie Gold
• Dauer 2:50 → 2:40 ±10 s — Kür jetzt 10 s zu lang
• Pflichtelement ChSp bleibt
Summe (Schätzung)
Basiswert 18,40 → 16,90 (−1,50)
```
### Randfälle
- **Ziel-Saison ohne Regeln** (`partial`, Zukunft): Aktion deaktiviert, Grund
genannt.
- **Kür ohne Saison:** derselbe Dialog dient als Erstzuordnung.
- **Ziel-Saison älter als die Kür:** erlaubt, mit Hinweis. Nützlich beim
Testen, harmlos im Ergebnis.
- **Ziel-Saison nicht installiert:** erst nach App-Update verfügbar; die
Auswahl zeigt nur vorhandene Saisons.
### Nebeneffekt
Der Katalog-Diff zweier Saisons ist genau die Änderungsliste, die `notes.md`
beschreibt. Dieselbe Mechanik kann später „Was ist neu in Saison X" erzeugen –
ohne zusätzliche Datenpflege.
## Pflegeablauf pro Saison
1. Ordner `2027-28/` anlegen, Manifest mit `status: partial` und
`inherit_from` für die noch fehlenden Papiere.
2. Neues SoV nicht abtippen: `tools/rules_diff.py 2026-27 2027-28` stellt die
Saisons gegenüber; getippt werden nur Änderungen. 43 Elemente × 5 Werte neu
zu erfassen ist eine Stunde Fehlerquelle, sechs geänderte Werte sind zehn
Minuten. Das Werkzeug ist noch nicht gebaut; bis dahin hilft
`git diff --no-index` über zwei Ordner.
3. `notes.md` mit den Änderungen füllen, die der Diff nicht erklärt.
4. `./tools/test.sh` – der Invariantenkatalog läuft mit.
5. Sobald die übrigen Papiere da sind: `file` statt `inherit_from`,
`status: complete`.
6. Ab dem `valid_from` schaltet sich die Saison von selbst scharf.
**Maßstab:** Wenn ein Saisonwechsel GDScript berührt, ist die Struktur nicht
fertig. Nachweis: `git diff --stat` zeigt nur `data/2027-28/**`.
## Migration der bestehenden Saisons
Ausgangslage: `isu_sov_2025_26.json`, `isu_levels_2025_26.json`,
`isu_sov_2026_27.json`, `isu_levels_2026_27.json`,
`isu_adult_2026_27.json`. 2025/26 hat keine Adult-Regeln.
### 2025/26
1. Ordner `2025-26/` anlegen, die beiden Dateien als `sov.json` und
`levels.json` übernehmen (Inhalt unverändert).
2. `manifest.json` mit `status: complete`, `replaces: null`.
3. **Adult nachtragen:** Das IAFSC-Announcement 2025/26 als `adult.json`
erfassen. Eine Lücke, die man mit einer Datei schließen kann, wird sonst zur
Dauererklärung im Prüfdialog („nicht anwendbar, keine Adult-Regeln").
Aktueller Stand: Der Eintrag steht auf `status: missing`, die Datei fehlt
noch. Die Saison bleibt trotzdem `complete`, weil Katalog und Level-Regeln
als Datei vorliegen.
4. **Policies backfillen** mit dem Stand, der 2025/26 tatsächlich galt
(mindestens `axel_required_in_sequence`).
5. `notes.md`: Was gilt, was fehlt, welche Policies nachgetragen wurden und
warum.
### 2026/27
1. Ordner `2026-27/` anlegen, drei Dateien als `sov.json`, `levels.json`,
`adult.json` übernehmen.
2. `manifest.json` mit `status: complete`, `replaces: "2025/26"` und den drei
Quellenangaben (Communication 2786, 2788, IAFSC-Announcement).
3. Policies aus dem heutigen Code übernehmen – insbesondere die Axel-Pflicht,
damit sich das Prüfergebnis gegenüber heute nicht ändert.
4. `notes.md` mit dem Diff gegen 2025/26 füllen.
5. Die fünf alten `isu_*.json` im selben Commit entfernen.
### Tests
`run_rules_tests.gd`, `run_level_tests.gd` und `run_adult_tests.gd` prüfen
heute absolute Werte der aktiven Saison. Umbau:
- Absolute Werte reduzieren auf eine Handvoll bewusst handgeprüfter Anker je
Saison.
- Der Rest wird Beziehungsprüfung (B7–B9, C6–C7) – die überlebt jeden
Saisonwechsel.
- Neu: der Saison-Paar-Test (E6).
## Umsetzungsreihenfolge
| Schritt | Inhalt | Fertig, wenn |
| :-- | :--- | :--- |
| 1 ✅ | `kind`-Lookup, Manifest, beide Ordner migriert | App lädt beide Saisons; `check_rules.sh` prüft A–D, F |
| 2 ✅ | `season` an der Kür, drei Zustände, Migration alter Dateien | Altkür ohne Saison zeigt „nicht festgelegt" und wird erst nach Auswahl geprüft |
| 3 ✅ | Validator als Funktion über (Kür, Regelpaket) | Kein globaler Katalog mehr in den Prüfpfaden; Saison-Paar-Test grün |
| 4 ✅ | Inspector, Picker, Kategorie folgen dem Kontext | Eine 2025/26-Kür bietet nur 2025/26-Elemente an |
| 5 ✅ | Saison-Anzeige in Statusleiste, Prüfdialog und PDF | Auf dem PDF ist die Saison lesbar |
| 6 | Saison-Upgrade-Prüfung | Beispielausgabe oben ist reproduzierbar |
| 7 | „Max. zwei Features pro Fuß" als Policy | Neue Regel ohne GDScript-Änderung ergänzbar |
Schritte 1 und 3 sind der Hebel; alles andere baut darauf auf.
## Bewusst nicht
- **Regel-Editor in der App.** Zweite Wahrheit, unversionierter Zustand.
- **Revisionen innerhalb einer Saison.** Die Saison wird mutiert, `notes.md`
dokumentiert (siehe oben).
- **Saisonordner löschen oder archivieren.** Alte Küren bleiben prüfbar.
- **Automatische Umbenennung von Codes beim Saisonwechsel.** Befund statt
stiller Anpassung.
- **Stillschweigende Saisonzuordnung** bei Kürdateien ohne das Feld.
## Offene Punkte
- Ob die Anwender-Doku (`docs/isu-rules.md`) vollständig generiert wird oder
nur die Tabellen und Zahlen.
- Ob der Upgrade-Bericht als PDF ausgegeben wird (für die Weitergabe an
Trainer und Eltern) – naheliegend, aber eigenes Feature.
- Ob `2025/26` auch im Inspector vollständig bedienbar bleibt (Elemente
anlegen) oder nur lesend geprüft wird. Die Entscheidung „alte Küren bleiben
gültig" verlangt Prüfbarkeit, nicht zwingend Bearbeitbarkeit.

View file

@ -15,6 +15,10 @@ Quellen:
Anleitung und Annahmen für die Bedienung: `docs/manual.md`.
Die **geplante** Mehrsaison-Struktur (Saisonordner, Manifest, deklarative
Policies, Saison-Upgrade-Prüfung) steht in `docs/isu-rules-structure.md`.
Sie ist noch nicht umgesetzt; bis zur Migration gilt dieses Dokument.
## Zweck
Der Katalog liefert die Base Values (BV) zu Elementkürzeln und Leveln. Er ist
@ -263,24 +267,23 @@ ein zweiter Klick blendet sie wieder aus.
## Neue Saison einpflegen
1. Neue ISU-Communication (Scale of Values) beschaffen und als JSON nach dem
obigen Schema anlegen, z. B. `isu_sov_2027_28.json`.
2. `season`, `valid_from` und `source` aktualisieren.
3. `ElementCatalog.DEFAULT_PATH` auf die neue Datei zeigen lassen.
4. Stichproben in `tests/run_rules_tests.gd` auf die neuen Werte anpassen
(mindestens ein Sprung, eine Pirouette, eine Sequenz).
5. Neue Level-Communication (Levels of Difficulty) als
`isu_levels_2027_28.json` anlegen, `ElementLevelRules.DEFAULT_PATH`
umstellen und `tests/run_level_tests.gd` anpassen.
6. Adult-Announcement der Saison als `isu_adult_2027_28.json` anlegen,
`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.
Die Saison ist ein Ordner unter `rinkplanner/src/core/rules/data/`. Die
verbindliche Struktur, das Manifest-Schema und der Invariantenkatalog stehen in
`docs/isu-rules-structure.md`. Kurzfassung:
Die JSON-Dateien werden über `include_filter="*.json"` in allen Export-Presets
mit ausgeliefert.
1. Ordner `2027-28/` anlegen und `manifest.json` schreiben (`season`,
`valid_from`, `replaces`, Dokumente mit Quelle). Fehlende Papiere als
`inherit_from` eintragen, `status` bleibt dann `partial`.
2. `sov.json`, `levels.json` und `adult.json` nach dem obigen Schema anlegen.
Die drei Dateien dürfen zu verschiedenen Terminen entstehen.
3. `notes.md` mit den Änderungen gegenüber der Vorsaison füllen.
4. `./tools/test.sh` (enthält `./tools/check_rules.sh`).
5. Sobald alle Papiere da sind: `inherit_from` durch `file` ersetzen,
`status: complete`.
GDScript muss dafür nicht angefasst werden; die App findet die Saison über das
Manifest. Die JSON-Dateien werden über `include_filter="*.json"` in allen
Export-Presets mit ausgeliefert.
## Nächste Ausbaustufen

View file

@ -7,7 +7,8 @@ App über den Button **?** in der Statusleiste erreichbar.
## Schnellstart
1. Kür anlegen oder öffnen.
2. In der Statusleiste die **Adult-Kategorie** wählen (Gold, Silver, Bronze,
2. In der Statusleiste die **Saison** prüfen (das Regelwerk, gegen das die Kür
geprüft wird) und die **Adult-Kategorie** wählen (Gold, Silver, Bronze,
Masters, Masters Elite).
3. Elemente aufs Eis setzen: Linie, Bogen, Freeline oder Element-Marker.
4. Im Element-Dialog **Kürzel**, **Features** und ggf. **Standzeit** festlegen.
@ -275,8 +276,31 @@ aktiv; damit startet z. B. das PDF direkt im PDF-Betrachter. Über
Schätzung nicht gewertet.
Der Katalog wird jährlich ersetzt. Die Daten liegen unter
`rinkplanner/src/core/rules/data/` und tragen Saison, Quelle und
Gültigkeitsdatum.
`rinkplanner/src/core/rules/data/` – je Saison ein Ordner mit Manifest und
drei Teildateien.
## Saison
Jede Kür gehört zu genau einer Saison, und sie wird **gegen das Regelwerk
dieser Saison** geprüft – nicht gegen das der installierten App-Version. Das
ist wichtig, weil eine Kür von 2025/26 nach den Regeln von 2025/26 bewertet
werden muss, auch wenn die App längst 2026/27 kennt.
Die Saison steht in der Statusleiste und wird mit der Kür gespeichert. Neue
Küren bekommen automatisch die gerade gültige Saison.
Drei Fälle:
- **Saison zugeordnet:** Prüfung läuft vollständig gegen diese Saison.
- **Saison nicht festgelegt** (alte Kürdateien): Die App prüft nichts, bis die
Saison gewählt ist. Der Tooltip nennt die Saison, die zum Dateidatum passt.
- **Saison unbekannt:** Die Kür stammt aus einer neueren Saison als die App
kennt. Zeichnen und Abspielen funktionieren, geprüft wird nicht – dafür ist
ein App-Update nötig.
Beim Wechsel der Saison bleiben die Elemente unverändert. Eine Adult-Kategorie,
die es in der neuen Saison nicht gibt, wird nicht gelöscht, sondern als
„nicht verfügbar" angezeigt.
## Sprungkombinationen

View file

@ -1,6 +1,6 @@
# Rinkplanner – Roadmap
Stand: 2026-11-11 (ISU 2026/27, Adult-Kategorien Gold/Silver/Bronze; JSON-Dateiformat, Export-Smoke-Test und Quality-Meilenstein ergänzt; Sport-Theme mit kompakteren Leisten, UI-Gliederung und mehr Rink-Fläche auf dem Tablet als Quality-Ziel aufgenommen; Sequenz-Erstellung auf Gruppieren umgestellt; Sync-Konflikte automatisch nach Inhalt-Zeitstempel aufgelöst, alter Kopienzoo aufräumbar sowie Küren zentral verwaltbar und umbenennbar; Cloud-Sync vorerst nur mit Dropbox)
Stand: 2026-11-13 (ISU 2026/27, Adult-Kategorien Gold/Silver/Bronze; JSON-Dateiformat, Export-Smoke-Test und Quality-Meilenstein ergänzt; Sport-Theme mit kompakteren Leisten, UI-Gliederung und mehr Rink-Fläche auf dem Tablet als Quality-Ziel aufgenommen; Sequenz-Erstellung auf Gruppieren umgestellt; Sync-Konflikte automatisch nach Inhalt-Zeitstempel aufgelöst, alter Kopienzoo aufräumbar sowie Küren zentral verwaltbar und umbenennbar; Cloud-Sync vorerst nur mit Dropbox; Regelwerk als Saisonordner mit deklarativen Policies und Saison-Upgrade-Prüfung verbindlich festgelegt, siehe `docs/isu-rules-structure.md`)
Diese Reihenfolge ist die verbindliche Arbeitsgrundlage für Phase 1. Änderungen
nur bewusst und nach Rücksprache. Letzte Erkenntnisse:
`docs/findings-2026-10-31-arm-gewichte.md`.
@ -170,7 +170,14 @@ OAuth-App ist nicht veröffentlicht. Google Drive und OneDrive stehen unter
- [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
- [x] Mehrsaison-Struktur: Regelpaket pro Saison (Ordner, Manifest,
deklarative Policies), alte Küren gegen ihre eigene Saison prüfen;
Zielbild und Invariantenkatalog in `docs/isu-rules-structure.md`
- [ ] Saison-Upgrade-Prüfung: bestehende Kür gegen eine andere Saison prüfen
und nur berichten („2 Elemente nicht mehr im Katalog", „1 Feature
entfallen", „Dauer jetzt 10 s zu lang"), ohne die Kür zu ändern
- [ ] Max. zwei Features pro Fuß und Feature-Positionsregeln
(als Policy in den Daten, nicht als Codebedingung)
- [x] Wiederholungsregeln (max. 2-mal pro gelistetem Sprung)
- [x] Kombinationsgrenzen (Anzahl, Folgen, max. Sprünge pro Kombination)
- [x] Strukturierte Sprungkombinationen/-folgen (erster Sprung + bis zu zwei weitere)
@ -206,9 +213,10 @@ fachlichen Validierung angefasst.
Die Reihenfolge ist bewusst: native Builds, Datenaustausch und Element-Marker
sind erledigt. Im PoC läuft jetzt das ISU-Regelwerk – Katalog 2026/27,
Level-Features, Elementvalidierung, Adult-Kategorien, Dauer und
Wiederholungs-/Kombinationsgrenzen stehen; als Nächstes folgen
Feature-Grenzen pro Fuß. GOE und Varianten sind vorerst zurückgestellt.
Sync-Komfort und
Wiederholungs-/Kombinationsgrenzen stehen; als Nächstes folgt die
Mehrsaison-Struktur (Regelpaket pro Saison, alte Küren bleiben gegen ihre
eigene Saison prüfbar) samt Saison-Upgrade-Prüfung, danach Feature-Grenzen pro
Fuß. GOE und Varianten sind vorerst zurückgestellt. Sync-Komfort und
UI-Refactoring sind zurückgestellt, weil der bestehende Stand für Tests
genügt und die endgültige Sync-Architektur (PHP-Webserver) sowie das
UI-Feedback der Tester ohnehin noch ausstehen.

View file

@ -750,3 +750,14 @@
"ⓘ Annahmen ändern","ⓘ Annahmen ändern","ⓘ Change assumptions"
"ⓘ Details ausblenden","ⓘ Details ausblenden","ⓘ Hide details"
"ⓘ Was ist enthalten?","ⓘ Was ist enthalten?","ⓘ What is included?"
"Saison %s","Saison %s","Season %s"
"Saison nicht festgelegt","Saison nicht festgelegt","Season not assigned"
"(unvollständig)","(unvollständig)","(incomplete)"
"Saison %s (unbekannt)","Saison %s (unbekannt)","Season %s (unknown)"
"Regelwerk, gegen das diese Kür geprüft wird","Regelwerk, gegen das diese Kür geprüft wird","Rulebook this programme is checked against"
"Ohne Saison kann die Kür nicht geprüft werden","Ohne Saison kann die Kür nicht geprüft werden","Without a season the programme cannot be checked"
"Vermutlich Saison %s (Dateidatum).","Vermutlich Saison %s (Dateidatum).","Probably season %s (file date)."
"Kategorie „%s“ nicht verfügbar","Kategorie „%s“ nicht verfügbar","Category “%s” not available"
"Saison nicht festgelegt: In der Statusleiste wählen, sonst prüft die App nichts.","Saison nicht festgelegt: In der Statusleiste wählen, sonst prüft die App nichts.","Season not assigned: pick one in the status bar, otherwise nothing is checked."
"Saison „%s“ kennt diese App-Version nicht. Bitte die App aktualisieren.","Saison „%s“ kennt diese App-Version nicht. Bitte die App aktualisieren.","This app version does not know season “%s”. Please update the app."
"nicht festgelegt","nicht festgelegt","not assigned"

1 keys de en
750 ⓘ Annahmen ändern ⓘ Annahmen ändern ⓘ Change assumptions
751 ⓘ Details ausblenden ⓘ Details ausblenden ⓘ Hide details
752 ⓘ Was ist enthalten? ⓘ Was ist enthalten? ⓘ What is included?
753 Saison %s Saison %s Season %s
754 Saison nicht festgelegt Saison nicht festgelegt Season not assigned
755 (unvollständig) (unvollständig) (incomplete)
756 Saison %s (unbekannt) Saison %s (unbekannt) Season %s (unknown)
757 Regelwerk, gegen das diese Kür geprüft wird Regelwerk, gegen das diese Kür geprüft wird Rulebook this programme is checked against
758 Ohne Saison kann die Kür nicht geprüft werden Ohne Saison kann die Kür nicht geprüft werden Without a season the programme cannot be checked
759 Vermutlich Saison %s (Dateidatum). Vermutlich Saison %s (Dateidatum). Probably season %s (file date).
760 Kategorie „%s“ nicht verfügbar Kategorie „%s“ nicht verfügbar Category “%s” not available
761 Saison nicht festgelegt: In der Statusleiste wählen, sonst prüft die App nichts. Saison nicht festgelegt: In der Statusleiste wählen, sonst prüft die App nichts. Season not assigned: pick one in the status bar, otherwise nothing is checked.
762 Saison „%s“ kennt diese App-Version nicht. Bitte die App aktualisieren. Saison „%s“ kennt diese App-Version nicht. Bitte die App aktualisieren. This app version does not know season “%s”. Please update the app.
763 nicht festgelegt nicht festgelegt not assigned

View file

@ -778,6 +778,12 @@ theme_override_font_sizes/font_size = 18
text = "?"
tooltip_text = "Hilfe und Annahmen"
[node name="SeasonOption" type="OptionButton" parent="Layout/StatusBar/StatusBarContent"]
unique_name_in_owner = true
custom_minimum_size = Vector2(190, 48)
layout_mode = 2
theme_override_font_sizes/font_size = 15
[node name="AdultCategoryOption" type="OptionButton" parent="Layout/StatusBar/StatusBarContent"]
unique_name_in_owner = true
custom_minimum_size = Vector2(170, 48)

View file

@ -175,6 +175,7 @@ static func decode_json(text: String) -> Dictionary:
routine.adult_category = (
_text(data, "adult_category", "").left(MAX_TEXT_LENGTH)
)
routine.season = _text(data, "season", "").left(MAX_TEXT_LENGTH)
routine.assumed_pcs_average = clampf(
_number(data, "assumed_pcs_average", 5.0),
0.0,
@ -282,6 +283,7 @@ static func encode(routine: Routine) -> String:
"saved_at": routine.saved_at,
"music_file": safe_music_file_name(routine.music_file),
"adult_category": routine.adult_category,
"season": routine.season,
"assumed_pcs_average": routine.assumed_pcs_average,
"assumed_falls": routine.assumed_falls,
"timeline_labels": _encode_timeline_labels(routine.timeline_labels),

View file

@ -4,7 +4,7 @@ extends Resource
## Root aggregate of a choreography. Pure data: no rendering, no input, no
## timing state. The whiteboard view and the future 3D layer both consume it.
const CURRENT_SCHEMA_VERSION := 6
const CURRENT_SCHEMA_VERSION := 7
@export var schema_version: int = CURRENT_SCHEMA_VERSION
@export var routine_id: String = ""
@ -22,6 +22,11 @@ const CURRENT_SCHEMA_VERSION := 6
## Adult competition category code (e.g. "gold", "silver", "bronze"). Empty
## means no category-specific validation.
@export var adult_category: String = ""
## Season whose rule package this routine is checked against ("2026/27").
## Empty means the season was never assigned; the app then cannot validate the
## elements and says so instead of guessing. The season is part of the file
## because an old routine must keep the rules it was skated under.
@export var season: String = ""
## Rough scoring assumptions for the estimate: average PCS per component
## (0-10) and number of falls.
@export var assumed_pcs_average: float = 5.0

View file

@ -8,7 +8,6 @@ extends RefCounted
## 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"]
@ -98,9 +97,6 @@ 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()

View file

@ -0,0 +1,27 @@
{
"schema_version": 1,
"season": "2025/26",
"label": "Saison 2025/26",
"valid_from": "2025-07-01",
"status": "complete",
"replaces": null,
"documents": {
"sov": {
"file": "sov.json",
"source": "ISU Communication No. 2707, Scale of Values valid as of July 1, 2025",
"valid_from": "2025-07-01"
},
"levels": {
"file": "levels.json",
"source": "ISU Communication No. 2701, Levels of Difficulty and Guidelines for marking Grade of Execution and Program Components, Season 2025/26",
"valid_from": "2025-07-01"
},
"adult": {
"status": "missing",
"reason": "Adult-Announcement 2025/26 nicht erfasst"
}
},
"policies": {
"axel_required_in_sequence": true
}
}

View file

@ -0,0 +1,38 @@
# Saison 2025/26 – Notizen zur Pflege
Stand: 2026-11-13
## Quellen
| Dokument | Communication | gültig ab |
| :--- | :--- | :--- |
| `sov.json` | ISU 2707 (Scale of Values) | 2025-07-01 |
| `levels.json` | ISU 2701 (Levels of Difficulty) | 2025-07-01 |
| `adult.json` | — **fehlt** — | — |
## Bekannte Lücken
- **Adult-Regeln fehlen.** Das IAFSC Technical Announcement 2025/26 ist nicht
erfasst. Der Eintrag im Manifest steht auf `status: missing`; die App meldet
die Kategorieprüfung deshalb als nicht anwendbar. Sobald das Announcement
vorliegt, wird `adult.json` ergänzt und der Manifest-Eintrag auf `file`
umgestellt.
- Die Saison steht trotzdem auf `status: complete`: vollständig heißt, dass
Katalog und Level-Regeln ohne Vererbung vorliegen. Fehlende Einzeldokumente
werden am Dokument gemeldet, nicht durch einen halben Saisonstatus.
- GOE-Tabellen und `V`-Varianten sind wie in allen Saisons bewusst offen.
## Nachgetragene Policies
Die Policies wurden beim Umzug auf die Saisonordner-Struktur aus dem damals
gültigen Code übernommen, nicht neu aus der Quelle gelesen:
- `axel_required_in_sequence: true` – der Validator erzwang die Axel-Pflicht in
Sprungfolgen bereits vor der Saisonordner-Struktur. Gegen Communication 2701
ist das noch nicht gegengeprüft; bis dahin bleibt das bisherige Verhalten
erhalten, damit sich Prüfergebnisse nicht rückwirkend ändern.
## Codes
`element_code` und die Feature-Codes werden in Kürdateien gespeichert. Sie
werden **nie** umbenannt; geändert werden nur `name` und `description`.

View file

@ -0,0 +1,28 @@
{
"schema_version": 1,
"season": "2026/27",
"label": "Saison 2026/27",
"valid_from": "2026-07-01",
"status": "complete",
"replaces": "2025/26",
"documents": {
"sov": {
"file": "sov.json",
"source": "ISU Communication No. 2786, Scale of Values and Program Components Factors valid as of July 1, 2026",
"valid_from": "2026-07-01"
},
"levels": {
"file": "levels.json",
"source": "ISU Communication No. 2788, Levels of Difficulty and Guidelines for marking Grade of Execution and Program Components, Season 2026/27",
"valid_from": "2026-06-01"
},
"adult": {
"file": "adult.json",
"source": "ISU International Adult Figure Skating Competitions 2026/27 – Technical Announcement",
"valid_from": "2026-07-01"
}
},
"policies": {
"axel_required_in_sequence": true
}
}

View file

@ -0,0 +1,42 @@
# Saison 2026/27 – Notizen zur Pflege
Stand: 2026-11-13
## Quellen
| Dokument | Communication | gültig ab |
| :--- | :--- | :--- |
| `sov.json` | ISU 2786 (Scale of Values) | 2026-07-01 |
| `levels.json` | ISU 2788 (Levels of Difficulty) | 2026-06-01 |
| `adult.json` | IAFSC Technical Announcement 2026/27 | 2026-07-01 |
Die drei Papiere erscheinen zu verschiedenen Terminen. Das ist zulässig; die
Prüfung A8 verlangt nur, dass alle im selben Saisonfenster liegen.
## Änderungen gegenüber 2025/26
- Katalog auf ISU 2786 umgestellt (vorher 2707).
- Level-Regeln auf ISU 2788 (vorher 2701).
- `ChSp1` als festes Level 1 ergänzt.
- Adult-Kategorien neu erfasst: Bronze, Silver, Gold, Masters, Masters Elite.
## Policies
- `axel_required_in_sequence: true` – Axel als zweiter oder dritter Sprung
einer Sprungfolge. Wurde aus dem bisher fest verdrahteten Validator
übernommen; das Verhalten der App ändert sich dadurch nicht.
- `max_features_per_foot` und `feature_position_rules` sind noch nicht
deklariert; die Regeln gelten in dieser Saison also nicht (F1).
## Bekannte Lücken
- GOE-Tabellen, `V`-Varianten, Unterrotations-/Fehlkanten-Suffixe und
Paarlauf-/Eistanz-Elemente sind bewusst nicht erfasst.
- `forbidden_jumps` in den Adult-Kategorien meint Element-Codes, nicht
Rotationen: In Gold steht `2A` in der Liste, obwohl `allow_axel: true` gilt.
Verboten ist der gesprungene 2A, nicht der Axel an sich.
## Codes
`element_code` und die Feature-Codes werden in Kürdateien gespeichert. Sie
werden **nie** umbenannt; geändert werden nur `name` und `description`.

View file

@ -9,7 +9,6 @@ extends RefCounted
## a level suffix ("CCoSp4", "StSqB"). Jump levels are ignored because jumps
## have a single base value.
const DEFAULT_PATH := "res://src/core/rules/data/isu_sov_2026_27.json"
const SUPPORTED_SCHEMA_VERSION := 1
const TYPE_BY_NAME := {
@ -29,9 +28,6 @@ var _by_key: Dictionary[String, ElementDefinition] = {}
var _errors: PackedStringArray = PackedStringArray()
static func load_default() -> ElementCatalog:
return load_from(DEFAULT_PATH)
static func load_from(path: String) -> ElementCatalog:
var catalog := ElementCatalog.new()

View file

@ -9,7 +9,6 @@ extends RefCounted
## only once per program, maximum features per foot) are stored in the data but
## not enforced here yet.
const DEFAULT_PATH := "res://src/core/rules/data/isu_levels_2026_27.json"
const SUPPORTED_SCHEMA_VERSION := 1
const MAX_LEVEL := PathSegment.ELEMENT_MAX_LEVEL
@ -50,9 +49,6 @@ var _fixed_levels: Dictionary[String, int] = {}
var _errors: PackedStringArray = PackedStringArray()
static func load_default() -> ElementLevelRules:
return load_from(DEFAULT_PATH)
static func load_from(path: String) -> ElementLevelRules:
var rules := ElementLevelRules.new()
@ -101,6 +97,14 @@ func get_fixed_level(type: PathSegment.ElementType, code: String) -> int:
return _fixed_levels[key]
## All codes that carry a fixed level, in data order.
func get_fixed_level_codes() -> PackedStringArray:
var codes := PackedStringArray()
for code: String in _fixed_levels:
codes.append(code)
return codes
func get_thresholds() -> Array[Dictionary]:
var copy: Array[Dictionary] = []
copy.assign(_thresholds)

View file

@ -0,0 +1,861 @@
class_name RulesAudit
extends RefCounted
## Checks the rule packages against the invariant catalog in
## `docs/isu-rules-structure.md` (groups A-F).
##
## The audit is pure data checking: it never changes a file and never loads the
## whiteboard. `tools/check_rules.sh` runs it headless, and
## `tests/run_rules_audit_tests.gd` exercises the checks themselves.
const SEVERITY_ERROR := 0
const SEVERITY_WARNING := 1
const JUMP_ORDER := ["T", "S", "Lo", "F", "Lz", "A"]
const MAX_BASE_VALUE := 15.0
const MIN_BASE_VALUE := 0.3
## Documents of one season may cite different valid_from dates (the ISU papers
## are published at different times), but they must share one season window.
const MAX_DOCUMENT_SPREAD_DAYS := 120
const ROTATION_NAMES := ["single", "double", "triple", "quad"]
class Finding extends RefCounted:
var severity: int = SEVERITY_ERROR
var code: String = ""
var season: String = ""
var message: String = ""
func is_error() -> bool:
return severity == SEVERITY_ERROR
func format() -> String:
var level := "FEHLER" if is_error() else "WARNUNG"
return "%s %s %s: %s" % [level, code, season, message]
class Report extends RefCounted:
var findings: Array[Finding] = []
var seasons_checked: int = 0
func error_count() -> int:
var count := 0
for finding: Finding in findings:
if finding.is_error():
count += 1
return count
func warning_count() -> int:
return findings.size() - error_count()
func is_ok() -> bool:
return error_count() == 0
func to_lines() -> PackedStringArray:
var lines := PackedStringArray()
for finding: Finding in findings:
lines.append(finding.format())
return lines
static func audit(library: RulesLibrary) -> Report:
var report := Report.new()
for error: String in library.get_errors():
_error(report, "", "LOAD", error)
var seasons := library.get_seasons()
report.seasons_checked = seasons.size()
if seasons.is_empty():
_error(report, "", "LOAD", "keine Saisonordner gefunden")
return report
for season: String in seasons:
_audit_manifest(report, library, season)
for season: String in seasons:
var package := library.get_package(season)
if package == null:
_error(report, season, "LOAD", "Saison lässt sich nicht laden")
continue
for error: String in package.get_errors():
_error(report, season, "LOAD", error)
for warning: String in package.get_warnings():
_warn(report, season, "LOAD", warning)
_audit_catalog(report, season, package)
_audit_levels(report, season, package)
_audit_adults(report, season, package)
_audit_policies(report, season, library, package)
_audit_season_diff(report, season, library, package)
return report
## Convenience for tooling: scans the default data root and audits it.
static func audit_root(root: String = RulesLibrary.DATA_ROOT) -> Report:
return audit(RulesLibrary.scan(root))
# --- A. Manifest und Ordner -------------------------------------------------
static func _audit_manifest(
report: Report,
library: RulesLibrary,
season: String
) -> void:
var data := library.get_manifest(season)
var folder := library.get_folder(season)
if folder.get_file() != RulesLibrary.season_to_folder(season):
_error(
report,
season,
"A1",
"Ordner '%s' passt nicht zur Saison '%s'"
% [folder.get_file(), RulesLibrary.season_to_folder(season)]
)
var schema := int(data.get("schema_version", 0))
if schema != RulesPackage.SUPPORTED_MANIFEST_SCHEMA:
_error(
report,
season,
"A2",
"unbekanntes Manifest-Schema %d" % schema
)
var valid_from := str(data.get("valid_from", "")).strip_edges()
if not _is_iso_date(valid_from):
_error(report, season, "A8", "'valid_from' ist kein Datum")
for kind: String in RulesPackage.DOCUMENT_KINDS:
var entry := _document_entry(data, kind)
if entry.is_empty():
_error(report, season, "A3", "Dokument '%s' fehlt im Manifest" % kind)
continue
var has_file := entry.has("file")
var has_inherit := entry.has("inherit_from")
var is_missing := (
str(entry.get("status", "")) == RulesPackage.DOCUMENT_STATUS_MISSING
)
var set_count := int(has_file) + int(has_inherit) + int(is_missing)
if set_count != 1:
_error(
report,
season,
"A4",
"Dokument '%s' braucht genau eines von 'file', 'inherit_from' "
% kind
+ "oder 'status: missing'"
)
continue
if has_file:
var path := folder.path_join(str(entry["file"]))
if not FileAccess.file_exists(path):
_error(report, season, "A5", "Datei '%s' fehlt" % path)
if has_inherit:
var base := str(entry["inherit_from"]).strip_edges()
if not library.has_season(base):
_error(
report,
season,
"A9",
"Dokument '%s' erbt von unbekannter Saison '%s'"
% [kind, base]
)
elif str(library.get_manifest(base).get("valid_from", "")) >= valid_from:
_error(
report,
season,
"A9",
"Dokument '%s' erbt von '%s', das nicht älter ist"
% [kind, base]
)
var document_valid_from := str(entry.get("valid_from", "")).strip_edges()
if not document_valid_from.is_empty():
if not _is_iso_date(document_valid_from):
_error(
report,
season,
"A8",
"'valid_from' von '%s' ist kein Datum" % kind
)
elif _is_iso_date(valid_from) and absi(
_days_between(valid_from, document_valid_from)
) > MAX_DOCUMENT_SPREAD_DAYS:
_error(
report,
season,
"A8",
"'%s' liegt mit %s außerhalb des Saisonfensters"
% [kind, document_valid_from]
)
var is_complete := str(data.get("status", "complete")).strip_edges() == "complete"
if is_complete:
for kind: String in RulesPackage.DOCUMENT_KINDS:
var entry := _document_entry(data, kind)
if entry.has("inherit_from"):
_error(
report,
season,
"A6",
"vollständige Saison erbt Dokument '%s'" % kind
)
for kind: String in ["sov", "levels"]:
if _document_entry(data, kind).has("status"):
_error(
report,
season,
"A6",
"vollständige Saison ohne Dokument '%s'" % kind
)
var replaces := ""
var raw_replaces: Variant = data.get("replaces", "")
if raw_replaces != null:
replaces = str(raw_replaces).strip_edges()
if replaces.is_empty():
if not _is_oldest_season(library, season):
_error(report, season, "A11", "'replaces' fehlt")
elif not library.has_season(replaces):
_error(
report,
season,
"A11",
"'replaces' verweist auf unbekannte Saison '%s'" % replaces
)
elif str(library.get_manifest(replaces).get("valid_from", "")) >= valid_from:
_error(
report,
season,
"A10",
"'replaces' ('%s') ist nicht älter als die Saison" % replaces
)
# --- B. Katalog -------------------------------------------------------------
static func _audit_catalog(
report: Report,
season: String,
package: RulesPackage
) -> void:
var catalog := package.catalog
if catalog == null:
return
var thresholds: Array[Dictionary] = []
if package.levels != null:
thresholds = package.levels.get_thresholds()
var seen: Dictionary[String, bool] = {}
for definition: ElementDefinition in catalog.get_definitions():
var code := definition.code
if code.strip_edges().is_empty() or code != code.strip_edges():
_error(report, season, "B1", "Kürzel '%s' ist leer oder hat Leerraum" % code)
if seen.has(code):
_error(report, season, "B1", "Kürzel '%s' ist doppelt" % code)
seen[code] = true
var levels: Array[int] = definition.get_levels()
var fixed := _fixed_level(package, definition)
if definition.element_type == PathSegment.ElementType.JUMP:
if not _is_jump_code(code):
_error(report, season, "B2", "Sprungkürzel '%s' hat ein unbekanntes Muster" % code)
if levels.size() != 1 or not levels.has(0):
_error(
report,
season,
"B3",
"Sprung '%s' muss genau einen Base Value (Level 0) haben" % code
)
elif fixed >= 0:
if levels.size() != 1 or not levels.has(fixed):
_error(
report,
season,
"B3",
"'%s' ist fest auf Level %d, hat aber %s"
% [code, fixed, str(levels)]
)
else:
if not levels.has(0) or levels.size() < 2:
_error(
report,
season,
"B3",
"'%s' braucht 'B' und mindestens ein Level" % code
)
for threshold: Dictionary in thresholds:
var level := int(threshold["level"])
if not levels.has(level):
_error(
report,
season,
"B4",
"'%s' fehlt der Base Value für Level %d" % [code, level]
)
_audit_level_ascending(report, season, code, definition)
for level: int in levels:
var value := definition.get_base_value(level)
if value < MIN_BASE_VALUE or value > MAX_BASE_VALUE:
_error(
report,
season,
"B5",
"'%s' Level %d liegt mit %.2f außerhalb des Bereichs"
% [code, level, value]
)
elif not is_equal_approx(value * 100.0, roundf(value * 100.0)):
_error(
report,
season,
"B5",
"'%s' Level %d hat mehr als zwei Nachkommastellen" % [code, level]
)
_audit_jump_families(report, season, catalog)
_audit_jump_order(report, season, catalog)
static func _audit_level_ascending(
report: Report,
season: String,
code: String,
definition: ElementDefinition
) -> void:
var levels: Array[int] = definition.get_levels()
for index: int in range(levels.size() - 1):
var lower := definition.get_base_value(levels[index])
var higher := definition.get_base_value(levels[index + 1])
if higher <= lower:
_error(
report,
season,
"B9",
"'%s': Level %d (%.2f) ist nicht höher als Level %d (%.2f)"
% [code, levels[index + 1], higher, levels[index], lower]
)
static func _audit_jump_families(
report: Report,
season: String,
catalog: ElementCatalog
) -> void:
for rotation: int in range(1, 5):
for jump_type: String in JUMP_ORDER:
var code := "%d%s" % [rotation, jump_type]
var definition := catalog.find(code)
if definition == null or (
definition.element_type != PathSegment.ElementType.JUMP
):
_warn(
report,
season,
"B6",
"Sprungfamilie '%s' fehlt (in notes.md begründen)" % code
)
static func _audit_jump_order(
report: Report,
season: String,
catalog: ElementCatalog
) -> void:
for rotation: int in range(1, 5):
var previous := -1.0
var previous_type := ""
for jump_type: String in JUMP_ORDER:
var definition := catalog.find("%d%s" % [rotation, jump_type])
if definition == null:
continue
var value := definition.get_base_value(0)
if previous >= 0.0 and value < previous:
_error(
report,
season,
"B7",
"%d%s (%.2f) ist weniger wert als %d%s (%.2f)"
% [rotation, jump_type, value, rotation, previous_type, previous]
)
previous = value
previous_type = jump_type
for jump_type: String in JUMP_ORDER:
var previous := -1.0
var previous_rotation := 0
for rotation: int in range(1, 5):
var definition := catalog.find("%d%s" % [rotation, jump_type])
if definition == null:
continue
var value := definition.get_base_value(0)
if previous >= 0.0 and value <= previous:
_error(
report,
season,
"B8",
"%d%s (%.2f) ist nicht höher als %d%s (%.2f)"
% [rotation, jump_type, value, previous_rotation, jump_type, previous]
)
previous = value
previous_rotation = rotation
# --- C. Level-Regeln --------------------------------------------------------
static func _audit_levels(
report: Report,
season: String,
package: RulesPackage
) -> void:
var rules := package.levels
var catalog := package.catalog
if rules == null or catalog == null:
return
var thresholds := rules.get_thresholds()
var last_level := 0
var last_min := 0
for threshold: Dictionary in thresholds:
var level := int(threshold["level"])
var min_features := int(threshold["min_features"])
if level != last_level + 1:
_error(
report,
season,
"C6",
"Level-Schwellen sind nicht lückenlos (%d nach %d)" % [level, last_level]
)
if level == 1 and min_features != 1:
_error(report, season, "C6", "Level 1 muss bei einem Feature beginnen")
if min_features <= last_min:
_error(
report,
season,
"C6",
"Level %d verlangt nicht mehr Features als das Level davor" % level
)
last_level = level
last_min = min_features
var max_level := last_level
var threshold_levels: Array[int] = []
for threshold: Dictionary in thresholds:
threshold_levels.append(int(threshold["level"]))
for definition: ElementDefinition in catalog.get_definitions():
if definition.element_type == PathSegment.ElementType.JUMP:
continue
var fixed := _fixed_level(package, definition)
var features := rules.get_features(definition.element_type)
if fixed >= 0:
continue
if features.is_empty():
_error(
report,
season,
"C2",
"'%s' ist levelbar, aber der Elementtyp hat keine Level-Regeln"
% definition.code
)
continue
var highest_min := int(thresholds[thresholds.size() - 1]["min_features"]) if (
not thresholds.is_empty()
) else 0
if highest_min > features.size():
_error(
report,
season,
"C7",
"Level %d verlangt %d Features, '%s' hat nur %d"
% [max_level, highest_min, definition.code, features.size()]
)
var element_levels: Array[int] = definition.get_levels()
for level: int in element_levels:
if level > 0 and not threshold_levels.has(level):
_error(
report,
season,
"C8",
"'%s' hat einen Base Value für Level %d, das es nicht gibt"
% [definition.code, level]
)
for code: String in rules.get_fixed_level_codes():
if not catalog.has_code(code):
_error(
report,
season,
"C1",
"festes Level für unbekanntes Element '%s'" % code
)
for type: int in [
PathSegment.ElementType.SPIN,
PathSegment.ElementType.SEQUENCE
]:
var seen: Dictionary[String, bool] = {}
for feature: ElementFeature in rules.get_features(type):
var key := feature.code.to_lower()
if seen.has(key):
_error(
report,
season,
"C3",
"Feature '%s' ist doppelt" % feature.code
)
seen[key] = true
if feature.description.strip_edges().is_empty():
_warn(
report,
season,
"C3",
"Feature '%s' hat keine Beschreibung" % feature.code
)
for required: String in rules.get_required_features(type):
if not seen.has(required.to_lower()):
_error(
report,
season,
"C4",
"Pflichtfeature '%s' ist nicht definiert" % required
)
for level4: String in rules.get_level4_features(type):
if not seen.has(level4.to_lower()):
_error(
report,
season,
"C5",
"Level-4-Feature '%s' ist nicht definiert" % level4
)
# --- D. Adult-Kategorien ----------------------------------------------------
static func _audit_adults(
report: Report,
season: String,
package: RulesPackage
) -> void:
var rules := package.adult
var catalog := package.catalog
if rules == null or catalog == null:
return
var max_level := 0
for threshold: Dictionary in package.levels.get_thresholds():
max_level = maxi(max_level, int(threshold["level"]))
var seen: Dictionary[String, bool] = {}
for category: AdultCategoryRules.Category in rules.get_categories():
var key := category.code.to_lower()
if seen.has(key):
_error(report, season, "D1", "Kategorie '%s' ist doppelt" % category.code)
seen[key] = true
if category.duration_seconds < 60 or category.duration_seconds > 300:
_error(
report,
season,
"D1",
"Kategorie '%s' hat eine unplausible Dauer" % category.code
)
for jump: String in category.forbidden_jumps:
var definition := catalog.find(jump)
if definition == null or (
definition.element_type != PathSegment.ElementType.JUMP
):
_error(
report,
season,
"D2",
"Kategorie '%s' verbietet unbekannten Sprung '%s'"
% [category.code, jump]
)
elif category.allow_axel and jump.to_upper().ends_with("A"):
_warn(
report,
season,
"D5",
"Kategorie '%s' erlaubt den Axel, verbietet aber '%s' – "
% [category.code, jump]
+ "falls bewusst, in notes.md begründen"
)
for rotation: String in category.allowed_rotations:
if not ROTATION_NAMES.has(rotation) and not rotation.is_empty():
_error(
report,
season,
"D3",
"Kategorie '%s' nennt unbekannte Rotation '%s'"
% [category.code, rotation]
)
if category.required_axel and not category.allow_axel:
_error(
report,
season,
"D4",
"Kategorie '%s' verlangt den Axel, erlaubt ihn aber nicht"
% category.code
)
if category.max_spin_level > max_level:
_error(
report,
season,
"D6",
"Kategorie '%s' erlaubt Spin-Level %d, es gibt nur %d"
% [category.code, category.max_spin_level, max_level]
)
if category.max_sequence_level > max_level:
_error(
report,
season,
"D6",
"Kategorie '%s' erlaubt Sequenz-Level %d, es gibt nur %d"
% [category.code, category.max_sequence_level, max_level]
)
if category.required_step_sequences > category.max_step_sequences:
_error(
report,
season,
"D7",
"Kategorie '%s' verlangt mehr Schrittsequenzen als erlaubt"
% category.code
)
if (
category.required_choreographic_sequences
> category.max_choreographic_sequences
):
_error(
report,
season,
"D7",
"Kategorie '%s' verlangt mehr Choreo-Sequenzen als erlaubt"
% category.code
)
if category.max_jump_combinations > 0 and (
category.max_jumps_per_combination < 2
):
_error(
report,
season,
"D8",
"Kategorie '%s' erlaubt Kombinationen mit weniger als zwei Sprüngen"
% category.code
)
if (
category.max_jumps_per_combination > category.max_jump_elements
and category.max_jump_elements > 0
):
_error(
report,
season,
"D11",
"Kategorie '%s' erlaubt mehr Sprünge pro Kombination als Elemente"
% category.code
)
if category.requires_choreographic_spin and not catalog.has_code("ChSp"):
_error(
report,
season,
"D9",
"Kategorie '%s' verlangt ChSp, das der Katalog nicht kennt"
% category.code
)
if category.pcs_factor <= 0.0 or category.fall_deduction < 0.0:
_error(
report,
season,
"D10",
"Kategorie '%s' hat unplausible Faktoren" % category.code
)
# --- F. Policies ------------------------------------------------------------
static func _audit_policies(
report: Report,
season: String,
library: RulesLibrary,
package: RulesPackage
) -> void:
for key: String in package.policies:
if not RulesPackage.KNOWN_POLICIES.has(key):
_error(
report,
season,
"F2",
"unbekannte Policy '%s'" % key
)
continue
var expected := str(RulesPackage.KNOWN_POLICIES[key])
var value: Variant = package.policies[key]
var actual_type := typeof(value)
if expected == "bool" and actual_type != TYPE_BOOL:
_error(report, season, "F3", "Policy '%s' muss true/false sein" % key)
elif expected == "int" and actual_type != TYPE_INT and not (
actual_type == TYPE_FLOAT and is_equal_approx(value, roundf(value))
):
_error(report, season, "F3", "Policy '%s' muss eine Zahl sein" % key)
if package.replaces.is_empty() or not library.has_season(package.replaces):
return
var base := library.get_package(package.replaces)
if base == null:
return
var notes := _read_notes(package)
for key: String in _policy_keys(package.policies):
if not _policy_keys(base.policies).has(key) and not notes.contains(key):
_warn(
report,
season,
"F4",
"neue Policy '%s' ist nicht in notes.md erwähnt" % key
)
for key: String in _policy_keys(base.policies):
if not _policy_keys(package.policies).has(key) and not notes.contains(key):
_warn(
report,
season,
"F4",
"Policy '%s' gilt nicht mehr, ist aber nicht in notes.md erwähnt"
% key
)
# --- E. Über Saisons hinweg -------------------------------------------------
static func _audit_season_diff(
report: Report,
season: String,
library: RulesLibrary,
package: RulesPackage
) -> void:
if package.replaces.is_empty() or not library.has_season(package.replaces):
return
var base := library.get_package(package.replaces)
if base == null or base.catalog == null or package.catalog == null:
return
var notes := _read_notes(package)
var current := _catalog_codes(package.catalog)
var previous := _catalog_codes(base.catalog)
for code: String in previous:
if not current.has(code) and not notes.contains(code):
_warn(
report,
season,
"E1",
"'%s' fehlt gegenüber %s, ist aber nicht in notes.md erwähnt"
% [code, package.replaces]
)
for code: String in current:
if not previous.has(code) and not notes.contains(code):
_warn(
report,
season,
"E2",
"'%s' ist neu gegenüber %s, steht aber nicht in notes.md"
% [code, package.replaces]
)
# --- Helpers ----------------------------------------------------------------
static func _policy_keys(policies: Dictionary) -> PackedStringArray:
var keys := PackedStringArray()
for key: String in policies:
keys.append(key)
return keys
static func _catalog_codes(catalog: ElementCatalog) -> Dictionary[String, bool]:
var codes: Dictionary[String, bool] = {}
for definition: ElementDefinition in catalog.get_definitions():
codes[definition.code] = true
return codes
static func _read_notes(package: RulesPackage) -> String:
var path := package.get_notes_path()
if path.is_empty() or not FileAccess.file_exists(path):
return ""
var file := FileAccess.open(path, FileAccess.READ)
return "" if file == null else file.get_as_text()
static func _fixed_level(package: RulesPackage, definition: ElementDefinition) -> int:
if package.levels == null:
return -1
return package.levels.get_fixed_level(definition.element_type, definition.code)
static func _document_entry(data: Dictionary, kind: String) -> Dictionary:
var documents: Variant = data.get("documents", {})
if typeof(documents) != TYPE_DICTIONARY:
return {}
var entry: Variant = (documents as Dictionary).get(kind, {})
if typeof(entry) != TYPE_DICTIONARY:
return {}
return entry as Dictionary
static func _is_oldest_season(library: RulesLibrary, season: String) -> bool:
var seasons := library.get_seasons()
return seasons.is_empty() or seasons[0] == season
static func _is_jump_code(code: String) -> bool:
if code.length() < 2:
return false
var rotation := code.substr(0, 1)
if not rotation.is_valid_int() or int(rotation) < 1 or int(rotation) > 4:
return false
return JUMP_ORDER.has(code.substr(1))
static func _is_iso_date(value: String) -> bool:
if value.length() != 10 or value[4] != "-" or value[7] != "-":
return false
var parts := value.split("-")
if parts.size() != 3:
return false
for part: String in parts:
if not part.is_valid_int():
return false
var month := int(parts[1])
var day := int(parts[2])
return month >= 1 and month <= 12 and day >= 1 and day <= 31
static func _days_between(from: String, to: String) -> int:
var a := Time.get_unix_time_from_datetime_string(from + "T00:00:00")
var b := Time.get_unix_time_from_datetime_string(to + "T00:00:00")
return int((b - a) / 86400.0)
static func _error(report: Report, season: String, code: String, message: String) -> void:
var finding := Finding.new()
finding.severity = SEVERITY_ERROR
finding.code = code
finding.season = season
finding.message = message
report.findings.append(finding)
static func _warn(report: Report, season: String, code: String, message: String) -> void:
var finding := Finding.new()
finding.severity = SEVERITY_WARNING
finding.code = code
finding.season = season
finding.message = message
report.findings.append(finding)

View file

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

View file

@ -0,0 +1,252 @@
class_name RulesLibrary
extends RefCounted
## Discovers the season rule packages under res://src/core/rules/data and
## loads them on demand.
##
## A season is identified by its manifest and rendered into a folder name by
## replacing "/" with "-" ("2026/27" -> "2026-27"). The library is the only
## place that knows file names; everything else asks for a season and receives
## a [RulesPackage].
const DATA_ROOT := "res://src/core/rules/data"
const MANIFEST_FILE := "manifest.json"
var _folders: Dictionary[String, String] = {}
var _manifests: Dictionary[String, Dictionary] = {}
var _packages: Dictionary[String, RulesPackage] = {}
var _errors: PackedStringArray = PackedStringArray()
static func scan(root: String = DATA_ROOT) -> RulesLibrary:
var library := RulesLibrary.new()
library._scan_root(root)
return library
func get_seasons() -> PackedStringArray:
var list: Array[String] = []
for season: String in _manifests:
list.append(season)
list.sort_custom(_compare_seasons)
var seasons := PackedStringArray()
for season: String in list:
seasons.append(season)
return seasons
func has_season(season: String) -> bool:
return _manifests.has(season.strip_edges())
func get_folder(season: String) -> String:
return _folders.get(season.strip_edges(), "")
func get_manifest(season: String) -> Dictionary:
return _manifests.get(season.strip_edges(), {})
## Returns the cached package, or null for an unknown season.
func get_package(season: String) -> RulesPackage:
var key := season.strip_edges()
if key.is_empty() or not _manifests.has(key):
return null
return _load_package(key, {})
## The season new routines should use: the newest complete season that has
## already started. Partial seasons never activate on their own, so a season
## whose papers are still missing cannot silently become the default.
func get_default_season(today: String = "") -> String:
var reference := today if not today.is_empty() else RulesLibrary.today()
var best := ""
var best_from := ""
for season: String in get_seasons():
var data := _manifests[season]
if str(data.get("status", "complete")).strip_edges() != "complete":
continue
var valid_from := str(data.get("valid_from", "")).strip_edges()
if valid_from <= reference and valid_from > best_from:
best = season
best_from = valid_from
if not best.is_empty():
return best
return get_latest_complete_season()
## Newest complete season, regardless of its validity date.
func get_latest_complete_season() -> String:
var best := ""
var best_from := ""
for season: String in get_seasons():
if str(_manifests[season].get("status", "complete")).strip_edges() != "complete":
continue
var valid_from := str(_manifests[season].get("valid_from", "")).strip_edges()
if valid_from > best_from:
best = season
best_from = valid_from
return best
## Newest season of any status. Used for messages when nothing is complete.
func get_latest_season() -> String:
var seasons := get_seasons()
return "" if seasons.is_empty() else seasons[seasons.size() - 1]
func get_errors() -> PackedStringArray:
return _errors.duplicate()
static func today() -> String:
return Time.get_date_string_from_system()
## "2026/27" -> "2026-27"
static func season_to_folder(season: String) -> String:
return season.strip_edges().replace("/", "-")
func _scan_root(root: String) -> void:
var dir := DirAccess.open(root)
if dir == null:
_errors.append("Regelordner '%s' nicht lesbar" % root)
return
dir.list_dir_begin()
var name := dir.get_next()
while not name.is_empty():
if dir.current_is_dir() and not name.begins_with("."):
_read_manifest(root.path_join(name))
name = dir.get_next()
dir.list_dir_end()
func _read_manifest(folder: String) -> void:
var path := folder.path_join(MANIFEST_FILE)
if not FileAccess.file_exists(path):
_errors.append("'%s' hat kein %s" % [folder, MANIFEST_FILE])
return
var file := FileAccess.open(path, FileAccess.READ)
if file == null:
_errors.append("'%s' nicht lesbar" % path)
return
var json := JSON.new()
if json.parse(file.get_as_text()) != OK:
_errors.append(
"'%s' ist kein gültiges JSON (Zeile %d)"
% [path, json.get_error_line()]
)
return
if typeof(json.data) != TYPE_DICTIONARY:
_errors.append("'%s' muss ein Objekt sein" % path)
return
var data := json.data as Dictionary
var season := str(data.get("season", "")).strip_edges()
if season.is_empty():
_errors.append("'%s' hat keine Saison" % path)
return
if _manifests.has(season):
_errors.append("Saison '%s' ist doppelt vorhanden" % season)
return
_manifests[season] = data
_folders[season] = folder
func _load_package(season: String, visiting: Dictionary) -> RulesPackage:
if _packages.has(season):
return _packages[season]
if visiting.has(season):
_errors.append("'%s' verweist im Kreis auf sich selbst" % season)
return null
visiting[season] = true
var package := RulesPackage.create(_folders[season], _manifests[season])
if package.season != season:
package.add_error(
"Saison im Manifest ('%s') passt nicht zum Verzeichnis ('%s')"
% [package.season, season]
)
for kind: String in RulesPackage.DOCUMENT_KINDS:
var entry := package.document_entry(kind)
if entry.is_empty():
package.add_error("Dokument '%s' fehlt im Manifest" % kind)
continue
if str(entry.get("status", "")) == RulesPackage.DOCUMENT_STATUS_MISSING:
package.add_warning(
"Dokument '%s' ist für diese Saison nicht erfasst" % kind
)
continue
if entry.has("inherit_from"):
var base_season := str(entry["inherit_from"]).strip_edges()
var base: RulesPackage = null
if _manifests.has(base_season):
base = _load_package(base_season, visiting)
if base == null:
package.add_error(
"Dokument '%s' verweist auf unbekannte Saison '%s'"
% [kind, base_season]
)
continue
package.inherited_from[kind] = base_season
_assign_document(package, kind, base, base_season)
continue
if not entry.has("file"):
package.add_error(
"Dokument '%s' hat weder 'file' noch 'inherit_from'" % kind
)
continue
var path := package.folder.path_join(str(entry["file"]))
_load_document(package, kind, path)
visiting.erase(season)
_packages[season] = package
return package
func _load_document(package: RulesPackage, kind: String, path: String) -> void:
if not FileAccess.file_exists(path):
package.add_error("Datei '%s' fehlt" % path)
return
match kind:
"sov":
var catalog := ElementCatalog.load_from(path)
package.catalog = catalog
for message: String in catalog.get_errors():
package.add_error("sov: %s" % message)
"levels":
var levels := ElementLevelRules.load_from(path)
package.levels = levels
for message: String in levels.get_errors():
package.add_error("levels: %s" % message)
"adult":
var adult := AdultCategoryRules.load_from(path)
package.adult = adult
for message: String in adult.get_errors():
package.add_error("adult: %s" % message)
func _assign_document(
package: RulesPackage,
kind: String,
base: RulesPackage,
base_season: String
) -> void:
match kind:
"sov":
package.catalog = base.catalog
"levels":
package.levels = base.levels
"adult":
package.adult = base.adult
if not package.has_document(kind):
package.add_error(
"Dokument '%s' aus '%s' ist dort nicht verfügbar" % [kind, base_season]
)
func _compare_seasons(a: String, b: String) -> bool:
return str(_manifests[a].get("valid_from", "")) < str(
_manifests[b].get("valid_from", "")
)

View file

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

View file

@ -0,0 +1,146 @@
class_name RulesPackage
extends RefCounted
## One season's complete rule package.
##
## A package bundles the three season documents (SoV catalog, level rules,
## adult categories) together with the season's policies. There is exactly one
## package per season; the folder name is the season with "-" instead of "/".
##
## Policies are season-scoped checks (e.g. "an Axel is required in a jump
## sequence"). A policy that a season does not declare is **inactive** for that
## season – there is deliberately no default, so old seasons never inherit
## rules that were invented later.
const SUPPORTED_MANIFEST_SCHEMA := 1
const DOCUMENT_KINDS: PackedStringArray = ["sov", "levels", "adult"]
const DOCUMENT_STATUS_MISSING := "missing"
## Policy keys the code knows, with their expected JSON type. Unknown keys in
## the data are an error (typo protection).
const KNOWN_POLICIES := {
"axel_required_in_sequence": "bool",
"max_features_per_foot": "int",
"feature_position_rules": "bool",
}
var folder: String = ""
var manifest: Dictionary = {}
var season: String = ""
var label: String = ""
var valid_from: String = ""
var status: String = ""
var replaces: String = ""
var policies: Dictionary = {}
var catalog: ElementCatalog
var levels: ElementLevelRules
var adult: AdultCategoryRules
## Document kind -> season the document was inherited from.
var inherited_from: Dictionary[String, String] = {}
var _errors: PackedStringArray = PackedStringArray()
var _warnings: PackedStringArray = PackedStringArray()
static func create(folder_path: String, data: Dictionary) -> RulesPackage:
var package := RulesPackage.new()
package.folder = folder_path
package.set_manifest(data)
return package
## Reads the header fields of a parsed manifest. Document entries are inspected
## through [method document_entry]; loading happens in [RulesLibrary].
func set_manifest(data: Dictionary) -> void:
manifest = data
season = str(data.get("season", "")).strip_edges()
label = str(data.get("label", "")).strip_edges()
valid_from = str(data.get("valid_from", "")).strip_edges()
status = str(data.get("status", "complete")).strip_edges()
var raw_replaces: Variant = data.get("replaces", "")
replaces = "" if raw_replaces == null else str(raw_replaces).strip_edges()
var raw_policies: Variant = data.get("policies", {})
if typeof(raw_policies) == TYPE_DICTIONARY:
policies = (raw_policies as Dictionary).duplicate()
else:
_errors.append("'policies' muss ein Objekt sein")
func is_complete() -> bool:
return status == "complete"
func document_entry(kind: String) -> Dictionary:
var documents: Variant = manifest.get("documents", {})
if typeof(documents) != TYPE_DICTIONARY:
return {}
var entry: Variant = (documents as Dictionary).get(kind, {})
if typeof(entry) != TYPE_DICTIONARY:
return {}
return entry as Dictionary
## True when the season actually provides usable data for [param kind].
func has_document(kind: String) -> bool:
match kind:
"sov":
return catalog != null
"levels":
return levels != null
"adult":
return adult != null
return false
func is_document_missing(kind: String) -> bool:
var entry := document_entry(kind)
return str(entry.get("status", "")) == DOCUMENT_STATUS_MISSING
## Source citation of one document, including the inheritance hint.
func get_document_source(kind: String) -> String:
var entry := document_entry(kind)
var source := str(entry.get("source", "")).strip_edges()
if inherited_from.has(kind):
var base := inherited_from[kind]
if source.is_empty():
return I18n.t("übernommen aus Saison %s") % base
return "%s (%s)" % [source, I18n.t("übernommen aus Saison %s") % base]
return source
func has_policy(key: String) -> bool:
return policies.has(key)
## Value of a season policy, or [param fallback] when the season does not
## declare it. Callers must pass the "off" value (false / 0) so that a missing
## key really disables the rule.
func get_policy(key: String, fallback: Variant = false) -> Variant:
if not policies.has(key):
return fallback
return policies[key]
func get_notes_path() -> String:
if folder.is_empty():
return ""
return folder.path_join("notes.md")
func add_error(message: String) -> void:
_errors.append(message)
func add_warning(message: String) -> void:
_warnings.append(message)
func get_errors() -> PackedStringArray:
return _errors.duplicate()
func get_warnings() -> PackedStringArray:
return _warnings.duplicate()

View file

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

View file

@ -100,10 +100,7 @@ const EXPORT_SHEET_SCENE := preload("res://scenes/export/export_sheet.tscn")
const PRESENTATION_3D_SCENE_PATH := "res://scenes/presentation3d/presentation_3d.tscn"
const PLAYBACK_PLAY_ICON := preload("res://assets/icons/playback/play.svg")
const PLAYBACK_PAUSE_ICON := preload("res://assets/icons/playback/pause.svg")
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 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 CODE_OPTION_PLACEHOLDER_ID := 0
const CODE_OPTION_FREE_ID := 1000000
@ -226,6 +223,7 @@ const UPDATE_FILE_NAMES := {
@onready var element_feature_hint: Label = %ElementFeatureHint
@onready var element_feature_menu: PopupMenu = %ElementFeatureMenu
@onready var validation_button: Button = %ValidationButton
@onready var season_option: OptionButton = %SeasonOption
@onready var adult_category_option: OptionButton = %AdultCategoryOption
@onready var validation_dialog: AcceptDialog = %ValidationDialog
@onready var validation_text: RichTextLabel = %ValidationText
@ -333,6 +331,9 @@ var _element_level: int = 0
var _element_catalog: ElementCatalog
var _level_rules: ElementLevelRules
var _adult_rules: AdultCategoryRules
var _rules_library: RulesLibrary
var _rules_package: RulesPackage
var _default_season: String = ""
var _dialog_features: PackedStringArray = PackedStringArray()
var _dialog_jump_kind: PathSegment.JumpKind = PathSegment.JumpKind.SOLO
var _dialog_combination_jumps: PackedStringArray = PackedStringArray()
@ -436,31 +437,15 @@ func _ready() -> void:
_apply_sport_theme()
_maximize_window_on_desktop.call_deferred()
autosave_timer.wait_time = AUTOSAVE_DELAY_SECONDS
_element_catalog = ELEMENT_CATALOG_SCRIPT.load_default()
if not _element_catalog.get_errors().is_empty():
push_warning(
"Element catalog: %s" % ", ".join(_element_catalog.get_errors())
)
_level_rules = ELEMENT_LEVEL_RULES_SCRIPT.load_default()
if not _level_rules.get_errors().is_empty():
push_warning(
"Level rules: %s" % ", ".join(_level_rules.get_errors())
)
_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 = (
"Prüft Kürzel, Elementtyp, Level, Features und Einmal-Regeln (Saison %s)"
% _element_catalog.season
)
_load_default_rules()
_refresh_validation_tooltip()
_setup_tool_buttons()
_setup_file_menu()
_setup_hub_controls()
_setup_playback_controls()
_setup_timing_controls()
_setup_element_controls()
_setup_season_controls()
_setup_adult_category_controls()
_setup_export_controls()
labels_toggle.set_pressed_no_signal(rink_canvas.labels_visible)
@ -605,6 +590,7 @@ func new_routine() -> void:
var routine := Routine.new()
routine.routine_id = "draft-routine"
routine.title = "Neue Kür"
routine.season = _default_season
routine.rink = RinkDimensions.new()
var section := RoutineSection.new()
@ -812,6 +798,58 @@ func get_level_rules() -> ElementLevelRules:
return _level_rules
func get_rules_package() -> RulesPackage:
return _rules_package
func get_rules_library() -> RulesLibrary:
return _rules_library
## Loads the season package new routines start with. Seasons are discovered on
## disk; there is no hardcoded file name here.
func _load_default_rules() -> void:
_rules_library = RulesLibrary.scan()
if not _rules_library.get_errors().is_empty():
push_warning("Rules: %s" % ", ".join(_rules_library.get_errors()))
_default_season = _rules_library.get_default_season()
if _default_season.is_empty():
push_warning("Rules: keine nutzbare Saison gefunden")
_apply_rules_for_season(_default_season)
## Resolves the rule package of one season and points the inspector, the
## category list and the validator at it. An empty or unknown season leaves the
## rules unset on purpose: the app then says that it cannot check instead of
## silently validating against the wrong rulebook.
func _apply_rules_for_season(season: String) -> void:
_rules_package = null
_element_catalog = null
_level_rules = null
_adult_rules = null
if _rules_library == null:
return
var cleaned := season.strip_edges()
if cleaned.is_empty():
return
_rules_package = _rules_library.get_package(cleaned)
if _rules_package == null:
return
for error: String in _rules_package.get_errors():
push_warning("Rules (%s): %s" % [_rules_package.season, error])
_element_catalog = _rules_package.catalog
_level_rules = _rules_package.levels
_adult_rules = _rules_package.adult
func _catalog_season_label() -> String:
if _rules_package != null and not _rules_package.season.is_empty():
return _rules_package.season
if _routine != null and not _routine.season.is_empty():
return _routine.season
return I18n.t("nicht festgelegt")
## Cross-checks all element segments against the catalog and level rules.
## Paths and section bookkeeping are validated by the model itself.
func validate_routine() -> Array[ValidationIssue]:
@ -848,9 +886,7 @@ func _render_validation_dialog() -> void:
report.issues,
ValidationIssue.Severity.WARNING
)
var season := (
_element_catalog.season if _element_catalog != null else "unbekannt"
)
var season := _catalog_season_label()
var lines := PackedStringArray()
lines.append(
@ -861,6 +897,9 @@ func _render_validation_dialog() -> void:
season,
]
)
var season_note := _season_note()
if not season_note.is_empty():
lines.append("[color=#e0b050]%s[/color]" % season_note)
var category: AdultCategoryRules.Category = null
if (
_routine != null
@ -2589,7 +2628,10 @@ func _setup_adult_category_controls() -> void:
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)
if not adult_category_option.item_selected.is_connected(
_on_adult_category_selected
):
adult_category_option.item_selected.connect(_on_adult_category_selected)
_sync_adult_category_option()
@ -2632,10 +2674,156 @@ func _sync_adult_category_option() -> void:
if str(adult_category_option.get_item_metadata(index)) == code:
adult_category_option.select(index)
return
# The stored category is not part of this season. Show it instead of
# pretending the routine has no category.
if not code.is_empty():
var index := adult_category_option.item_count
adult_category_option.add_item(
I18n.t("Kategorie „%s“ nicht verfügbar") % code.capitalize(),
index
)
adult_category_option.set_item_metadata(index, code)
adult_category_option.select(index)
return
if adult_category_option.item_count > 0:
adult_category_option.select(0)
## Fills the season dropdown. The list comes from the rules library, so a new
## season folder appears without touching this code.
func _setup_season_controls() -> void:
if season_option == null:
return
if not season_option.item_selected.is_connected(_on_season_selected):
season_option.item_selected.connect(_on_season_selected)
_sync_season_option()
func _sync_season_option() -> void:
if season_option == null:
return
var current := _routine.season.strip_edges() if _routine != null else ""
season_option.clear()
var selected := -1
if current.is_empty():
season_option.add_item(I18n.t("Saison nicht festgelegt"), 0)
season_option.set_item_metadata(0, "")
selected = 0
if _rules_library != null:
for season: String in _rules_library.get_seasons():
var index := season_option.item_count
var label := I18n.t("Saison %s") % season
var status := str(
_rules_library.get_manifest(season).get("status", "complete")
).strip_edges()
if status != "complete":
label += " " + I18n.t("(unvollständig)")
season_option.add_item(label, index)
season_option.set_item_metadata(index, season)
if season == current:
selected = index
if not current.is_empty() and selected < 0:
var index := season_option.item_count
season_option.add_item(I18n.t("Saison %s (unbekannt)") % current, index)
season_option.set_item_metadata(index, current)
selected = index
if selected >= 0:
season_option.select(selected)
season_option.tooltip_text = _season_tooltip(current)
func _season_tooltip(current: String) -> String:
if not current.is_empty():
return I18n.t("Regelwerk, gegen das diese Kür geprüft wird")
var inferred := _infer_season_from_current_path()
if inferred.is_empty():
return I18n.t("Ohne Saison kann die Kür nicht geprüft werden")
return (
I18n.t("Ohne Saison kann die Kür nicht geprüft werden")
+ " "
+ I18n.t("Vermutlich Saison %s (Dateidatum).") % inferred
)
## Best guess for a routine that predates the season field: the season that was
## valid when its file was last written. Only used as a hint, never applied.
func _infer_season_from_current_path() -> String:
if _current_path.is_empty() or _rules_library == null:
return ""
if not FileAccess.file_exists(_current_path):
return ""
var unix := FileAccess.get_modified_time(_current_path)
if unix <= 0:
return ""
var date := Time.get_date_string_from_unix_time(unix)
return _rules_library.get_default_season(date)
func _on_season_selected(index: int) -> void:
set_season(str(season_option.get_item_metadata(index)))
## Assigns the season whose rules the routine is checked against. Empty clears
## the assignment; unknown seasons are rejected so a typo cannot mute the
## validation.
func set_season(season: String) -> bool:
if _routine == null:
return false
var cleaned := season.strip_edges()
if _routine.season == cleaned:
return false
if (
not cleaned.is_empty()
and (_rules_library == null or not _rules_library.has_season(cleaned))
):
return false
_record_undo()
_routine.season = cleaned
_apply_rules_for_season(cleaned)
_sync_season_option()
_setup_adult_category_controls()
_mark_dirty()
_update_status()
_refresh_validation_tooltip()
if validation_dialog != null and validation_dialog.visible:
_render_validation_dialog()
return true
func get_season() -> String:
return _routine.season if _routine != null else ""
## One line that explains why the check cannot use a rule package, if that is
## the case. Empty when the season resolved normally.
func _season_note() -> String:
if _rules_package != null:
return ""
var raw := _routine.season.strip_edges() if _routine != null else ""
if raw.is_empty():
var inferred := _infer_season_from_current_path()
var note := I18n.t(
"Saison nicht festgelegt: In der Statusleiste wählen, sonst prüft die App nichts."
)
if not inferred.is_empty():
note += " " + I18n.t("Vermutlich Saison %s (Dateidatum).") % inferred
return note
return I18n.t(
"Saison „%s“ kennt diese App-Version nicht. Bitte die App aktualisieren."
) % raw
func _refresh_validation_tooltip() -> void:
if validation_button != null:
validation_button.tooltip_text = I18n.t(
"Prüft Kürzel, Elementtyp, Level, Features und Einmal-Regeln (Saison %s)"
) % _catalog_season_label()
func _on_element_code_text_changed(_text: String) -> void:
_update_level_control_state()
update_element_feature_hint()
@ -3004,6 +3192,7 @@ func _clone_routine(source: Routine) -> Routine:
clone.music_file = source.music_file
clone.timeline_labels.assign(source.timeline_labels.duplicate(true))
clone.adult_category = source.adult_category
clone.season = source.season
clone.assumed_pcs_average = source.assumed_pcs_average
clone.assumed_falls = source.assumed_falls
if source.rink != null:
@ -5374,6 +5563,7 @@ func _set_routine(routine: Routine, path: String) -> void:
if not path.is_empty():
_save_session_path(path)
_delete_autosave()
_sync_season_option()
_undo_stack.clear()
_redo_stack.clear()
@ -5408,7 +5598,9 @@ func _install_routine(
for segment: PathSegment in section.segments:
if segment != null:
segment.normalize_jump_combination()
_sync_adult_category_option()
_apply_rules_for_season(_routine.season)
_sync_season_option()
_setup_adult_category_controls()
var valid_sections: Array[RoutineSection] = []
for section: RoutineSection in _routine.sections:

View file

@ -339,6 +339,9 @@ static func _routine_subtitle(routine: Routine, section_count: int) -> String:
var category := routine.adult_category.strip_edges()
if not category.is_empty():
parts.append("Kategorie: %s" % category.capitalize())
var season := routine.season.strip_edges()
if not season.is_empty():
parts.append(I18n.t("Saison %s") % season)
parts.append("%d Abschnitte" % section_count)
parts.append(I18n.t("Gesamt %s") % _fmt_clock(routine.get_duration_seconds()))
if routine.has_music():

View file

@ -0,0 +1,25 @@
extends SceneTree
## Prints the invariant report for all season rule packages.
##
## Run with:
## ./tools/check_rules.sh
##
## Exit code 0 means "no errors"; warnings are printed but do not fail, because
## they are deliberately non-blocking notes (e.g. a missing jump family that
## notes.md explains).
func _init() -> void:
var report := RulesAudit.audit_root()
var lines := report.to_lines()
for line: String in lines:
print(line)
var errors := report.error_count()
var warnings := report.warning_count()
print(
"%d Saison(s) geprüft: %d Fehler, %d Warnung(en)"
% [report.seasons_checked, errors, warnings]
)
quit(1 if errors > 0 else 0)

View file

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

View file

@ -5,13 +5,11 @@ extends SceneTree
## 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")
const SEASON := "2026/27"
var _assertions: int = 0
var _failures: PackedStringArray = PackedStringArray()
@ -22,9 +20,15 @@ var _validator: RoutineValidator
func _init() -> void:
_catalog = ElementCatalogScript.load_default()
_rules = ElementLevelRulesScript.load_default()
_adult = AdultCategoryRulesScript.load_default()
var library := RulesLibrary.scan()
var package := library.get_package(SEASON)
_check(package != null, "Saison %s ist ladbar" % SEASON)
if package == null:
_finish()
return
_catalog = package.catalog
_rules = package.levels
_adult = package.adult
_validator = RoutineValidatorScript.new(_catalog, _rules, _adult)
_test_metadata()

View file

@ -72,6 +72,7 @@ func _test_json_roundtrip() -> void:
"second timeline label survives"
)
_check(loaded.adult_category == routine.adult_category, "category survives")
_check(loaded.season == routine.season, "season survives")
_check_approx(
loaded.assumed_pcs_average,
routine.assumed_pcs_average,
@ -212,6 +213,21 @@ func _test_json_rejects() -> void:
RoutineFile.json_path("user://kuer.tres") == "user://kuer.json",
"legacy paths migrate to the JSON extension"
)
# Files written before the season field existed stay loadable and are not
# silently assigned to a season.
var legacy_data: Dictionary = JSON.parse_string(encoded)
legacy_data.erase("season")
var without_season := RoutineFile.decode_json(JSON.stringify(legacy_data))
_check(
str(without_season["error"]).is_empty(),
"a file without a season still loads"
)
var old_routine: Routine = without_season["routine"]
_check(
old_routine != null and old_routine.season.is_empty(),
"a missing season stays unassigned"
)
_check(
RoutineFile.json_path("user://kuer") == "user://kuer.json",
"paths without extension get .json"
@ -363,6 +379,7 @@ func _make_routine() -> Routine:
{"time_seconds": 1.25, "text": "Dreh"},
]
routine.adult_category = "gold"
routine.season = "2026/27"
routine.assumed_pcs_average = 4.75
routine.assumed_falls = 1
routine.rink = RinkDimensions.new()

View file

@ -5,8 +5,8 @@ extends SceneTree
## Run with:
## godot --headless --path rinkplanner --script res://tests/run_level_tests.gd
const ElementLevelRulesScript := preload("res://src/core/rules/element_level_rules.gd")
const PathSegmentModel := preload("res://src/core/model/path_segment.gd")
const SEASON := "2026/27"
var _assertions: int = 0
var _failures: PackedStringArray = PackedStringArray()
@ -14,7 +14,13 @@ var _rules: ElementLevelRules
func _init() -> void:
_rules = ElementLevelRulesScript.load_default()
var library := RulesLibrary.scan()
var package := library.get_package(SEASON)
_check(package != null, "Saison %s ist ladbar" % SEASON)
if package == null:
_finish()
return
_rules = package.levels
_test_rules_metadata()
_test_spin_levels()

View file

@ -0,0 +1,296 @@
extends SceneTree
## Headless tests for the season rule packages and the invariant audit.
##
## Run with:
## godot --headless --path rinkplanner --script res://tests/run_rules_audit_tests.gd
const FIXTURE_ROOT := "user://rules-audit-fixture"
var _assertions: int = 0
var _failures: PackedStringArray = PackedStringArray()
func _init() -> void:
_test_library_discovery()
_test_season_resolution()
_test_package_contents()
_test_real_data_passes_audit()
_test_broken_fixture_is_reported()
_test_season_pair_difference()
_cleanup()
_finish()
func _test_library_discovery() -> void:
var library := RulesLibrary.scan()
_check(library.get_errors().is_empty(), "rule library scans without errors")
var seasons := library.get_seasons()
_check(seasons.has("2025/26"), "library knows 2025/26")
_check(seasons.has("2026/27"), "library knows 2026/27")
_check(seasons.size() == 2, "library finds exactly two seasons")
_check(
seasons[0] == "2025/26" and seasons[1] == "2026/27",
"seasons are sorted oldest first"
)
_check(library.has_season("2026/27"), "has_season finds 2026/27")
_check(not library.has_season("2030/31"), "has_season rejects unknown")
_check(library.get_package("2030/31") == null, "unknown season has no package")
func _test_season_resolution() -> void:
var library := RulesLibrary.scan()
_check(
library.get_default_season("2026-11-13") == "2026/27",
"mid season 2026/27 is the default"
)
_check(
library.get_default_season("2026-06-30") == "2025/26",
"before July 1st the previous season is the default"
)
_check(
library.get_default_season("2025-06-01") == "2026/27",
"without a started season the newest complete season wins"
)
_check(
RulesLibrary.season_to_folder("2026/27") == "2026-27",
"season folder name uses a dash"
)
func _test_package_contents() -> void:
var library := RulesLibrary.scan()
var current := library.get_package("2026/27")
_check(current != null, "2026/27 package loads")
if current == null:
return
_check(current.get_errors().is_empty(), "2026/27 package has no errors")
_check(current.is_complete(), "2026/27 is complete")
_check(current.season == "2026/27", "package carries its season")
_check(current.replaces == "2025/26", "2026/27 replaces 2025/26")
_check(current.catalog != null, "package has a catalog")
_check(current.levels != null, "package has level rules")
_check(current.adult != null, "package has adult categories")
_check(current.get_notes_path().ends_with("notes.md"), "package knows its notes")
var policy: Variant = current.get_policy("axel_required_in_sequence", false)
_check(policy == true, "axel policy is declared for 2026/27")
_check(
current.get_policy("max_features_per_foot", 0) == 0,
"undeclared policy falls back to the caller's off value"
)
_check(
not current.has_policy("feature_position_rules"),
"undeclared policy is reported as absent"
)
var previous := library.get_package("2025/26")
_check(previous != null, "2025/26 package loads")
if previous == null:
return
_check(previous.catalog != null, "2025/26 has a catalog")
_check(previous.levels != null, "2025/26 has level rules")
_check(previous.adult == null, "2025/26 has no adult rules")
_check(previous.is_document_missing("adult"), "2025/26 marks adult as missing")
_check(
not previous.get_warnings().is_empty(),
"2025/26 warns about the missing document"
)
func _test_real_data_passes_audit() -> void:
var report := RulesAudit.audit_root()
_check(report.seasons_checked == 2, "audit checks both seasons")
_check(
report.error_count() == 0,
"real data passes the audit (%s)"
% "; ".join(report.to_lines())
)
func _test_broken_fixture_is_reported() -> void:
_cleanup()
_copy_season("2026/27", FIXTURE_ROOT.path_join("2026-27"))
var manifest_path := FIXTURE_ROOT.path_join("2026-27").path_join("manifest.json")
var manifest := _read_json(manifest_path)
manifest["replaces"] = null
var policies: Dictionary = manifest["policies"]
policies["unknown_policy"] = true
manifest["policies"] = policies
_write_json(manifest_path, manifest)
var sov_path := FIXTURE_ROOT.path_join("2026-27").path_join("sov.json")
var sov := _read_json(sov_path)
for entry: Dictionary in sov["elements"]:
if str(entry.get("code", "")) == "3Lz":
entry["base_value"] = 3.0
_write_json(sov_path, sov)
var levels_path := FIXTURE_ROOT.path_join("2026-27").path_join("levels.json")
var levels := _read_json(levels_path)
var fixed_levels: Dictionary = levels["fixed_levels"]
fixed_levels["9Zz"] = 1
levels["fixed_levels"] = fixed_levels
_write_json(levels_path, levels)
var report := RulesAudit.audit_root(FIXTURE_ROOT)
var codes := PackedStringArray()
for finding: RulesAudit.Finding in report.findings:
if not codes.has(finding.code):
codes.append(finding.code)
_check(codes.has("B7"), "audit reports a broken jump order (B7)")
_check(codes.has("C1"), "audit reports an unknown fixed level code (C1)")
_check(codes.has("F2"), "audit reports an unknown policy (F2)")
_check(report.error_count() >= 3, "fixture has at least three errors")
# A document must not be both a file and an inheritance.
var manifest_broken := _read_json(manifest_path)
var adult: Dictionary = manifest_broken["documents"]["adult"]
adult["inherit_from"] = "2025/26"
manifest_broken["documents"]["adult"] = adult
_write_json(manifest_path, manifest_broken)
var broken := RulesAudit.audit_root(FIXTURE_ROOT)
var broken_codes := PackedStringArray()
for finding: RulesAudit.Finding in broken.findings:
broken_codes.append(finding.code)
_check(broken_codes.has("A4"), "audit rejects file plus inherit_from (A4)")
## E6: a reference routine must pass in one season and fail in the next for
## exactly the documented reason. This is what keeps old rules from being
## "repaired" by accident.
func _test_season_pair_difference() -> void:
var library := RulesLibrary.scan()
var older := library.get_package("2025/26")
var newer := library.get_package("2026/27")
_check(older != null and newer != null, "both seasons load for the pair test")
if older == null or newer == null:
return
var routine := _make_pair_routine()
var old_issues := RoutineValidator.new(
older.catalog,
older.levels,
older.adult
).validate(routine)
var new_issues := RoutineValidator.new(
newer.catalog,
newer.levels,
newer.adult
).validate(routine)
_check(
_has_message(old_issues, "nicht im Katalog"),
"2025/26 does not know ChSp"
)
_check(
not _has_message(new_issues, "nicht im Katalog"),
"2026/27 knows ChSp"
)
_check(older.adult == null, "2025/26 has no adult rules")
_check(newer.adult != null, "2026/27 has adult rules")
func _make_pair_routine() -> Routine:
var routine := Routine.new()
routine.routine_id = "season-pair"
routine.season = "2026/27"
var section := RoutineSection.new()
section.section_id = "section-001"
section.title = "Abschnitt 1"
section.sequence_order = 0
routine.sections = [section]
var marker := PathSegment.new()
marker.segment_id = "seg-chsp"
var curve := Curve2D.new()
curve.add_point(Vector2.ZERO)
marker.curve = curve
marker.element_type = PathSegment.ElementType.SPIN
marker.element_code = "ChSp"
marker.element_level = 1
section.segments.append(marker)
return routine
func _has_message(
issues: Array[ValidationIssue],
fragment: String
) -> bool:
for issue: ValidationIssue in issues:
if issue.message.contains(fragment):
return true
return false
func _copy_season(season: String, target: String) -> void:
var source := RulesLibrary.DATA_ROOT.path_join(season.replace("/", "-"))
DirAccess.make_dir_recursive_absolute(target)
var dir := DirAccess.open(source)
if dir == null:
return
dir.list_dir_begin()
var name := dir.get_next()
while not name.is_empty():
if not dir.current_is_dir():
var data := FileAccess.get_file_as_bytes(source.path_join(name))
var file := FileAccess.open(target.path_join(name), FileAccess.WRITE)
if file != null:
file.store_buffer(data)
name = dir.get_next()
dir.list_dir_end()
func _read_json(path: String) -> Dictionary:
var file := FileAccess.open(path, FileAccess.READ)
if file == null:
return {}
var parsed: Variant = JSON.parse_string(file.get_as_text())
return parsed as Dictionary if typeof(parsed) == TYPE_DICTIONARY else {}
func _write_json(path: String, data: Dictionary) -> void:
var file := FileAccess.open(path, FileAccess.WRITE)
if file == null:
return
file.store_string(JSON.stringify(data, " "))
func _cleanup() -> void:
_remove_dir(FIXTURE_ROOT)
func _remove_dir(path: String) -> void:
var dir := DirAccess.open(path)
if dir == null:
return
dir.list_dir_begin()
var name := dir.get_next()
while not name.is_empty():
if dir.current_is_dir():
_remove_dir(path.path_join(name))
else:
dir.remove(name)
name = dir.get_next()
dir.list_dir_end()
DirAccess.remove_absolute(path)
func _check(condition: bool, message: String) -> void:
_assertions += 1
if not condition:
_failures.append(message)
func _finish() -> void:
if _failures.is_empty():
print("PASS: %d assertions" % _assertions)
quit(0)
return
for failure: String in _failures:
printerr("FAIL: %s" % failure)
printerr("%d of %d assertions failed" % [_failures.size(), _assertions])
quit(1)

View file

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

View file

@ -7,6 +7,7 @@ extends SceneTree
const ElementDefinitionScript := preload("res://src/core/rules/element_definition.gd")
const ElementCatalogScript := preload("res://src/core/rules/element_catalog.gd")
const SEASON := "2026/27"
const PathSegmentModel := preload("res://src/core/model/path_segment.gd")
var _assertions: int = 0
@ -15,7 +16,13 @@ var _catalog: ElementCatalog
func _init() -> void:
_catalog = ElementCatalogScript.load_default()
var library := RulesLibrary.scan()
var package := library.get_package(SEASON)
_check(package != null, "Saison %s ist ladbar" % SEASON)
if package == null:
_finish()
return
_catalog = package.catalog
_test_catalog_metadata()
_test_jump_values()

View file

@ -5,13 +5,12 @@ extends SceneTree
## Run with:
## godot --headless --path rinkplanner --script res://tests/run_validation_tests.gd
const ElementCatalogScript := preload("res://src/core/rules/element_catalog.gd")
const ElementLevelRulesScript := preload("res://src/core/rules/element_level_rules.gd")
const RoutineValidatorScript := preload("res://src/core/rules/routine_validator.gd")
const ValidationIssueScript := preload("res://src/core/rules/validation_issue.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")
const SEASON := "2026/27"
var _assertions: int = 0
var _failures: PackedStringArray = PackedStringArray()
@ -21,8 +20,14 @@ var _validator: RoutineValidator
func _init() -> void:
_catalog = ElementCatalogScript.load_default()
_rules = ElementLevelRulesScript.load_default()
var library := RulesLibrary.scan()
var package := library.get_package(SEASON)
_check(package != null, "Saison %s ist ladbar" % SEASON)
if package == null:
_finish()
return
_catalog = package.catalog
_rules = package.levels
_validator = RoutineValidatorScript.new(_catalog, _rules)
_test_clean_routine()

View file

@ -1675,6 +1675,75 @@ func _run() -> void:
)
controller.validation_dialog.hide()
# Season assignment: the routine carries the rule package it is checked
# against, and a season switch must not silently rewrite its data.
controller.new_routine()
_check(
controller.get_season() == "2026/27",
"a new routine gets the default season"
)
_check(
controller.get_rules_package() != null
and controller.get_rules_package().season == "2026/27",
"the active rule package matches the routine"
)
_check(
controller.set_adult_category("gold"),
"Gold is available in the default season"
)
_check(controller.set_season("2025/26"), "the season can be switched to 2025/26")
_check(
controller.get_rules_package().season == "2025/26",
"the rule package follows the season"
)
_check(
controller.get_routine().adult_category == "gold",
"the category is kept when the target season lacks adult rules"
)
var unavailable_index := -1
for index: int in range(controller.adult_category_option.item_count):
if str(controller.adult_category_option.get_item_metadata(index)) == "gold":
unavailable_index = index
_check(unavailable_index >= 0, "the stored category stays visible")
_check(
controller.adult_category_option.get_item_text(unavailable_index).contains(
"nicht verfügbar"
),
"an unavailable category is labelled instead of hidden"
)
_check(
controller.adult_category_option.selected == unavailable_index,
"the dropdown selects the unavailable category"
)
var selected_season := controller.season_option.selected
_check(
str(controller.season_option.get_item_metadata(selected_season)) == "2025/26",
"the season dropdown reflects the routine"
)
_check(controller.set_season(""), "the season can be cleared")
_check(
controller.get_rules_package() == null,
"without a season there is no rule package"
)
var unassigned_issues := controller.validate_routine()
_check(
not unassigned_issues.is_empty(),
"an unassigned season blocks element validation"
)
controller.open_validation_dialog()
_check(
controller.validation_text.text.contains("Saison nicht festgelegt"),
"the dialog explains the missing season"
)
controller.validation_dialog.hide()
_check(
not controller.set_season("2030/31"),
"an unknown season is rejected"
)
controller.new_routine()
# Structured jump combination in the element dialog.
controller.new_routine()
var combo_marker := controller.add_element_marker(

22
tools/check_rules.sh Executable file
View file

@ -0,0 +1,22 @@
#!/usr/bin/env bash
set -euo pipefail
REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
PROJECT_DIR="$REPO_ROOT/rinkplanner"
GODOT="${GODOT:-/opt/godot/Godot_v4.7.2-stable_linux.x86_64}"
if [[ ! -x "$GODOT" && -x "/Applications/Godot.app/Contents/MacOS/Godot" ]]; then
GODOT="/Applications/Godot.app/Contents/MacOS/Godot"
fi
if [[ ! -x "$GODOT" ]]; then
echo "Godot binary not found: $GODOT" >&2
echo "Set GODOT=/path/to/godot" >&2
exit 1
fi
# Import first so global class names are registered.
"$GODOT" --headless --path "$PROJECT_DIR" --import >/dev/null 2>&1 || true
"$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/check_rules.gd

View file

@ -33,6 +33,9 @@ fi
"$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/run_file_format_tests.gd
"$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/run_rules_audit_tests.gd
"$GODOT" --headless --path "$PROJECT_DIR" \
--script res://tests/run_rules_tests.gd