diff --git a/docs/isu-rules-structure.md b/docs/isu-rules-structure.md index 0e9bda1..0c564f6 100644 --- a/docs/isu-rules-structure.md +++ b/docs/isu-rules-structure.md @@ -2,10 +2,10 @@ Stand: 2026-11-13 -Status: **umgesetzt** bis auf Schritt 7. Saisonordner, Manifest, Policies, -Invariantenkatalog A–F, Saison an der Kür, Validator pro Regelpaket, -Oberfläche, Export und die Saison-Upgrade-Prüfung stehen. Offen sind die -Feature-Grenzen pro Fuß (Schritt 7) und eine PDF-Ausgabe des Vergleichs. +Status: **umgesetzt.** Alle sieben Schritte der Umsetzungsreihenfolge stehen: +Saisonordner, Manifest, Policies, Invariantenkatalog A–F, Saison an der Kür, +Validator pro Regelpaket, Oberfläche, Export, Saison-Upgrade-Prüfung und die +Feature-Grenzen. Offen ist nur eine PDF-Ausgabe des Saisonvergleichs. ## Zweck @@ -198,14 +198,14 @@ 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 + "axel_required_in_sequence": true } ``` Die Policies stehen im **Manifest** der Saison, nicht in den Teildateien: Sie betreffen die Programmprüfung als Ganzes, nicht ein einzelnes Dokument. +Regeln, die zu einem Elementtyp gehören (Schwellen, Gruppen, Fuß-Deckel), +stehen dagegen in `levels.json` – dort, wo auch die Features liegen. 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, @@ -226,8 +226,9 @@ ist wertlos. | 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` | +| **Max. zwei Variationen pro Pirouette** | Daten (Gruppe) | `types.spin.groups` | +| **Max. zwei Features pro Fuß** | Daten (Typ) | `types.spin.max_features_per_foot` | +| **Feature-Positionsregeln** | Code + Daten | Variationen sind nach Grundposition getrennt | | Adult-Grenzen | Daten | `adult.json` | Die Axel-Pflicht steht heute im Code und gilt damit rückwirkend für jede @@ -512,7 +513,7 @@ heute absolute Werte der aktiven Saison. Umbau: | 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 | +| 7 ✅ | „Max. zwei Features pro Fuß" und Variationen pro Kategorie | Neue Regel ohne GDScript-Änderung ergänzbar | Schritte 1 und 3 sind der Hebel; alles andere baut darauf auf. diff --git a/docs/isu-rules.md b/docs/isu-rules.md index 30014b9..2be46e7 100644 --- a/docs/isu-rules.md +++ b/docs/isu-rules.md @@ -15,9 +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. +Die Mehrsaison-Struktur (Saisonordner, Manifest, deklarative Policies, +Invarianten, Saison-Upgrade-Prüfung) ist umgesetzt; Format und Pflege stehen in +`docs/isu-rules-structure.md`. Dieses Dokument beschreibt, was in der Saison +gilt, und wird bei jeder neuen Saison fortgeschrieben. ## Zweck @@ -126,7 +127,7 @@ Level 4 nötig ist. | Elementtyp | Features | Besonderheit | | :--- | :--- | :--- | -| Pirouette | 15 | Max. 2 schwierige Variationen; Level 4 verlangt eines von 6 Features inkl. Windmills | +| Pirouette | 19 | 5 Varianten-Kategorien; max. 2 Variationen und max. 2 Features pro Fuß; Level 4 verlangt eines von 6 Features inkl. Windmills | | Schrittsequenz | 5 | Feature 1 (Vielfalt) ist Pflicht; ohne sie bleibt die Sequenz Base | | `ChSq` / `ChSp` | – | Fest Level 1 | | Sprung | – | Nicht levelbar | @@ -136,6 +137,18 @@ werden: schwieriger Ausgang, klare Kantenänderung, beide Richtungen, klare Temposteigerung, schwieriger Flug-Eingang oder **Windmills**. Der frühere „schwierige Positionswechsel“ ist kein Pflichtfeature mehr. +Drei Grenzen gelten zusätzlich (ISU 2788): + +- **Variationen sind nach Grundposition getrennt** (`difficult_variation_sit`, + `_camel`, `_layback`, `_upright`, `_other`). Jede Kategorie zählt einmal pro + Programm. +- **Höchstens zwei Variationen** zählen pro Pirouette, auch wenn mehr + angehakt sind. +- **Höchstens zwei Features pro Fuß** zählen in einer Pirouette mit + Fußwechsel. Dafür speichert das Segment den Fuß je Feature + (`element_feature_feet`); die App fragt ihn nur ab, wenn mehr als zwei + fußbezogene Features gewählt sind. + Die Schwelle ist für beide Typen gleich: 1 Feature → Level 1, 2 → Level 2, 3 → Level 3, 4 oder mehr → Level 4. Ohne Feature bleibt das Element Base. `ElementLevelRules.calculate_level()` liefert neben dem Level auch die @@ -146,21 +159,23 @@ var rules := ElementLevelRules.load_default() var result := rules.calculate_level( PathSegment.ElementType.SPIN, "CCoSp", - PackedStringArray(["difficult_variation", "difficult_exit"]) + PackedStringArray(["difficult_variation_sit", "difficult_exit"]), + {"difficult_variation_sit": "L"} ) # result.level == 2, result.counted_features == 2 ``` Das Segment speichert die Auswahl als `element_features` -(`PackedStringArray`). Duplikate sind erlaubt, damit zwei schwierige -Variationen als zwei Features zählen. Für Katalog-Elemente setzt der -Controller den Level automatisch aus dem Feature-Ergebnis. Sprünge sind fest -Base, `ChSq` und `ChSp` fest Level 1. Unbekannte Freitext-Codes behalten -einen manuellen Level als Fallback. Die Daten enthalten außerdem -`once_per_program` (Feature zählt nur beim ersten Versuch im Programm) und -`max_per_element`. Die Programmprüfung wertet `once_per_program` aus und -meldet ab dem zweiten Element eine Warnung. Die Begrenzung „max. zwei -Features pro Fuß“ und die Feature-Positionsregeln sind noch nicht umgesetzt. +(`PackedStringArray`, jeder Code höchstens einmal) und optional den Fuß als +`element_feature_feet`. Für Katalog-Elemente setzt der Controller den Level +automatisch aus dem Feature-Ergebnis. Sprünge sind fest Base, `ChSq` und +`ChSp` fest Level 1. Unbekannte Freitext-Codes behalten einen manuellen Level +als Fallback. Die Daten enthalten außerdem `once_per_program` (Feature zählt +nur beim ersten Versuch im Programm), `per_foot` und Feature-Gruppen mit +eigenem Deckel (`groups`). Die Programmprüfung wertet `once_per_program` aus, +meldet ab dem zweiten Element eine Warnung und prüft Gruppen- sowie +Fuß-Deckel; fehlt bei mehr als zwei fußbezogenen Features die Fußangabe, +weist sie darauf hin. ## Adult-Kategorien diff --git a/docs/manual.md b/docs/manual.md index 30322e9..a224b8f 100644 --- a/docs/manual.md +++ b/docs/manual.md @@ -348,8 +348,11 @@ Für Pirouetten und Schrittsequenzen gilt: | 3 | Level 3 | | 4 oder mehr | Level 4 | -- **Pirouetten:** 15 Features (2026/27). Maximal zwei schwierige Variationen - zählen pro Pirouette. Für Level 4 ist zusätzlich eines dieser Features +- **Pirouetten:** 19 Features (2026/27), darunter fünf Varianten-Kategorien + (Sitz, Camel, Layback, Upright, Sonstige). Maximal zwei Variationen zählen + pro Pirouette, jede Kategorie einmal pro Programm. Zusätzlich zählen + höchstens zwei Features pro Fuß; bei einer Pirouette mit Fußwechsel fragt + die App den Fuß ab, sobald mehr als zwei fußbezogene Features gewählt sind. Für Level 4 ist zusätzlich eines dieser Features nötig: schwieriger Ausgang, klare Kantenänderung, beide Richtungen, klare Temposteigerung, schwieriger Flug-Eingang oder **Windmills**. - **Schrittsequenzen:** 5 Features. Feature 1 (Vielfalt schwieriger Schritte diff --git a/docs/roadmap.md b/docs/roadmap.md index 44821eb..dc7010b 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -176,8 +176,9 @@ OAuth-App ist nicht veröffentlicht. Google Drive und OneDrive stehen unter - [x] 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] Max. zwei Features pro Fuß (nur bei Fußwechsel-Pirouetten, Abfrage erst + ab drei fußbezogenen Features) und max. zwei Variationen pro Pirouette, je + Kategorie einmal pro Programm - [x] Artistic Free Skating als schmaler Modus (Entscheidung der Fachgruppe 2026-11-13: Punktwertung nicht wichtig, Länge und Begrenzungen schon). `program_type` als zweite Achse, Kategorien je Programmtyp, keine @@ -391,6 +392,23 @@ Abschnitte, Labels, Export. Elemente, Regelwerk und vor allem die Geometrie > spätere Erweiterung derselben App: gleiche Linienlogik, anderer > Elementkorpus. +**Name für das eigene Werkzeug: `RinkFormation`** (Vorratsentscheidung, +2026-11-13). Der Name hält das Domänenwort „Rink“ konstant – wie bei +`Rinkplanner` und dem Hub – und tauscht nur die Funktion. „Formation“ ist +zugleich der Begriff aus dem Regelwerk, „Rink“ nimmt die Mehrdeutigkeit des +Wortes heraus (Militär, Geologie, Firmengründung). Verworfen: +`FormationPlanner` (dreht das Muster um – Funktion konstant, Domäne getauscht – +und liest sich als Regal „XPlanner“, außerdem im Fußball als Taktikbrett +besetzt), `RinkForm` (kürzer, aber ohne „Formation“ nicht selbsterklärend) und +die bildstarken Varianten `RinkWeave`/`RinkShape` (im Deutschen schlecht +aussprechbar). Namensraum: Repo und Godot-Projekt `rinkformation`, Kennung +`de.programmschmiede.rinkformation`, Domain `rinkformation.de` (am 2026-11-13 +ohne DNS-Eintrag; Markenrecherche beim DPMA offen). + +Das ist Vorratshaltung, keine Planung: Interessant wird das Werkzeug erst, wenn +der Rinkplanner praktisch ausentwickelt ist. Bis dahin bleibt der Name eine +Notiz in diesem Dokument. + ## Später: Build-Größe (ganz am Ende) - [ ] Intel-Support für macOS aufgeben: nur noch arm64 bauen. Das Universal diff --git a/rinkplanner/assets/i18n/strings.csv b/rinkplanner/assets/i18n/strings.csv index be25633..1ccd983 100644 --- a/rinkplanner/assets/i18n/strings.csv +++ b/rinkplanner/assets/i18n/strings.csv @@ -792,3 +792,9 @@ "Artistic wird nur über die Programmkomponenten bewertet; keine Punktschätzung.","Artistic wird nur über die Programmkomponenten bewertet; keine Punktschätzung.","Artistic is judged on the programme components only; no score estimate." "Sprungelemente min.","Sprungelemente min.","Jump elements min." "Pirouetten min.","Pirouetten min.","Spins min." +"Links","Links","Left" +"Rechts","Rechts","Right" +"Fuß je Feature: Es zählen höchstens zwei Features pro Fuß.","Fuß je Feature: Es zählen höchstens zwei Features pro Fuß.","Foot per feature: at most two features per foot count." +"Fuß nicht angegeben für „%s“; max. zwei Features pro Fuß sind nicht prüfbar.","Fuß nicht angegeben für „%s“; max. zwei Features pro Fuß sind nicht prüfbar.","Foot missing for “%s”; the limit of two features per foot cannot be checked." +"„%s“: %d Features auf einem Fuß, es zählen höchstens %d.","„%s“: %d Features auf einem Fuß, es zählen höchstens %d.","“%s”: %d features on one foot, at most %d count." +"Bei „%s“ zählen höchstens %d Features der Gruppe „%s“.","Bei „%s“ zählen höchstens %d Features der Gruppe „%s“.","In “%s” at most %d features of the group “%s” count." diff --git a/rinkplanner/scenes/whiteboard/whiteboard.tscn b/rinkplanner/scenes/whiteboard/whiteboard.tscn index 3ac5e6e..3f332fe 100644 --- a/rinkplanner/scenes/whiteboard/whiteboard.tscn +++ b/rinkplanner/scenes/whiteboard/whiteboard.tscn @@ -1006,6 +1006,22 @@ theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) theme_override_font_sizes/font_size = 14 autowrap_mode = 3 +[node name="SpinFootHint" type="Label" parent="ElementDialog/ElementBox"] +unique_name_in_owner = true +visible = false +custom_minimum_size = Vector2(480, 0) +layout_mode = 2 +theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) +theme_override_font_sizes/font_size = 13 +text = "Fuß je Feature: Es zählen höchstens zwei Features pro Fuß." +autowrap_mode = 3 + +[node name="SpinFootPanel" type="VBoxContainer" parent="ElementDialog/ElementBox"] +unique_name_in_owner = true +visible = false +layout_mode = 2 +theme_override_constants/separation = 2 + [node name="MarkerTimingRow" type="HBoxContainer" parent="ElementDialog/ElementBox"] layout_mode = 2 theme_override_constants/separation = 12 diff --git a/rinkplanner/src/core/io/routine_file.gd b/rinkplanner/src/core/io/routine_file.gd index 36f3366..2330f59 100644 --- a/rinkplanner/src/core/io/routine_file.gd +++ b/rinkplanner/src/core/io/routine_file.gd @@ -345,6 +345,9 @@ static func _encode_segment(segment: PathSegment) -> Dictionary: var features: Array = [] for feature: String in segment.element_features: features.append(feature) + var feet: Dictionary = {} + for code: String in segment.element_feature_feet: + feet[code] = segment.element_feature_feet[code] var combination: Array = [] for jump: String in segment.combination_jumps: combination.append(jump) @@ -380,6 +383,7 @@ static func _encode_segment(segment: PathSegment) -> Dictionary: "code": segment.element_code, "level": segment.element_level, "features": features, + "feature_feet": feet, "jump_kind": _jump_kind_name(segment.jump_kind), "combination_jumps": combination, "duration_seconds": segment.element_duration_seconds, @@ -564,7 +568,14 @@ static func _decode_segment(data: Dictionary) -> Dictionary: features.append(feature) if features.size() >= MAX_FEATURES: break - segment.set_element_features(features) + var feet_value: Variant = element.get("feature_feet", {}) + var feet: Dictionary = {} + if feet_value is Dictionary: + for key: Variant in feet_value as Dictionary: + var foot := str((feet_value as Dictionary)[key]).strip_edges().to_upper() + if foot == "L" or foot == "R": + feet[str(key).strip_edges()] = foot + segment.set_element_features(features, feet) var jump_kind := _jump_kind_from_name( _text(element, "jump_kind", "solo") diff --git a/rinkplanner/src/core/model/path_segment.gd b/rinkplanner/src/core/model/path_segment.gd index 7854b2d..9a35cec 100644 --- a/rinkplanner/src/core/model/path_segment.gd +++ b/rinkplanner/src/core/model/path_segment.gd @@ -88,6 +88,10 @@ const ELEMENT_MAX_JUMP_DISTANCE_M := 30.0 ## are allowed for features that can count more than once, e.g. difficult ## variations in a spin. @export var element_features: PackedStringArray = PackedStringArray() +## Foot a level feature was performed on, keyed by feature code ("L" or "R"). +## Only relevant for spins with a change of foot: the ISU counts at most two +## features per foot there. Features without an entry are foot-neutral. +@export var element_feature_feet: Dictionary[String, String] = {} ## Stand time of a point marker in seconds (jump air time, spin rotation). It is ## independent of the geometry; ranges use [member duration_seconds] instead. @export var element_duration_seconds: float = 0.0 @@ -208,11 +212,13 @@ func set_element(type: ElementType, code: String, level: int) -> void: element_code = "" element_level = 0 element_features = PackedStringArray() + element_feature_feet = {} jump_kind = JumpKind.SOLO combination_jumps = PackedStringArray() return if type != previous_type: element_features = PackedStringArray() + element_feature_feet = {} jump_kind = JumpKind.SOLO combination_jumps = PackedStringArray() if type != ElementType.JUMP: @@ -222,22 +228,42 @@ func set_element(type: ElementType, code: String, level: int) -> void: element_level = clampi(level, 0, ELEMENT_MAX_LEVEL) -## Replaces the selected level features. Empty codes are dropped, order is -## preserved and duplicates are kept for multi-count features. -func set_element_features(features: PackedStringArray) -> void: +## Replaces the selected level features. Empty codes are dropped and order is +## preserved; duplicates are dropped because every feature counts at most once +## per element (variations are split by position in the data). +## +## [param feet] optionally maps feature codes to "L"/"R". Entries for features +## that are not selected are discarded. +func set_element_features( + features: PackedStringArray, + feet: Dictionary = {} +) -> void: if element_type == ElementType.NONE: element_features = PackedStringArray() + element_feature_feet = {} return var cleaned := PackedStringArray() for raw: String in features: var code := raw.strip_edges() - if code.is_empty(): + if code.is_empty() or cleaned.has(code): continue cleaned.append(code) if cleaned.size() >= ELEMENT_MAX_FEATURES: break element_features = cleaned + var cleaned_feet: Dictionary[String, String] = {} + for code: String in cleaned: + var foot := str(feet.get(code, "")).strip_edges().to_upper() + if foot == "L" or foot == "R": + cleaned_feet[code] = foot + element_feature_feet = cleaned_feet + + +## Foot ("L"/"R") of a selected feature, or "" when it is not attributed. +func get_feature_foot(code: String) -> String: + return element_feature_feet.get(code.strip_edges(), "") + ## Stores a structured jump combination or sequence. [member element_code] ## remains the first jump; up to two additional jumps are kept. @@ -508,6 +534,14 @@ func validate() -> PackedStringArray: if feature != feature.strip_edges(): errors.append("element_features must be trimmed") break + for code: String in element_feature_feet: + if not element_features.has(code): + errors.append("element_feature_feet refers to an unselected feature") + break + var foot: String = element_feature_feet[code] + if foot != "L" and foot != "R": + errors.append("element_feature_feet must be L or R") + break if element_type != ElementType.JUMP: if jump_kind != JumpKind.SOLO or not combination_jumps.is_empty(): errors.append("jump combinations need a jump element") diff --git a/rinkplanner/src/core/model/routine.gd b/rinkplanner/src/core/model/routine.gd index ed6d154..48ebb58 100644 --- a/rinkplanner/src/core/model/routine.gd +++ b/rinkplanner/src/core/model/routine.gd @@ -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 := 8 +const CURRENT_SCHEMA_VERSION := 9 @export var schema_version: int = CURRENT_SCHEMA_VERSION @export var routine_id: String = "" diff --git a/rinkplanner/src/core/rules/data/2025-26/levels.json b/rinkplanner/src/core/rules/data/2025-26/levels.json index decf284..cb57a0d 100644 --- a/rinkplanner/src/core/rules/data/2025-26/levels.json +++ b/rinkplanner/src/core/rules/data/2025-26/levels.json @@ -5,16 +5,34 @@ "valid_from": "2025-07-01", "source": "ISU Communication No. 2701, Levels of Difficulty and Guidelines for marking Grade of Execution and Program Components, Season 2025/26", "levels": [ - { "level": 1, "min_features": 1 }, - { "level": 2, "min_features": 2 }, - { "level": 3, "min_features": 3 }, - { "level": 4, "min_features": 4 } + { + "level": 1, + "min_features": 1 + }, + { + "level": 2, + "min_features": 2 + }, + { + "level": 3, + "min_features": 3 + }, + { + "level": 4, + "min_features": 4 + } ], "fixed_levels": { "ChSq": 1 }, "types": { "spin": { + "max_features_per_foot": 2, + "groups": { + "difficult_variation": { + "max_per_element": 2 + } + }, "required_features": [], "level4_requires_any": [ "difficult_position_change", @@ -26,107 +44,160 @@ ], "features": [ { - "code": "difficult_variation", - "name": "Schwierige Variation", - "description": "Schwierige Variation einer Grundposition; höchstens zwei zählen pro Pirouette.", - "max_per_element": 2, - "once_per_program": false + "code": "difficult_variation_sit", + "name": "Schwierige Variation — Sitz", + "description": "Schwierige Variation in der Sitzposition. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" + }, + { + "code": "difficult_variation_camel", + "name": "Schwierige Variation — Camel", + "description": "Schwierige Variation in der Camelposition. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" + }, + { + "code": "difficult_variation_layback", + "name": "Schwierige Variation — Layback", + "description": "Schwierige Variation in der Laybackposition. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" + }, + { + "code": "difficult_variation_upright", + "name": "Schwierige Variation — Upright", + "description": "Schwierige Variation in einer aufrechten Position. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" + }, + { + "code": "difficult_variation_other", + "name": "Schwierige Variation — Sonstige", + "description": "Schwierige Variation außerhalb der Grundpositionen. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" }, { "code": "change_foot_jump", "name": "Fußwechsel per Sprung", "description": "Fußwechsel mit einem Sprung ausgeführt.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": false }, { "code": "jump_in_spin", "name": "Sprung in der Pirouette", "description": "Sprung innerhalb der Pirouette ohne Fußwechsel.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "difficult_position_change", "name": "Schwieriger Positionswechsel", "description": "Schwieriger Positionswechsel auf demselben Fuß.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "difficult_entrance", "name": "Schwieriger Eingang", "description": "Schwieriger Eingang in die Pirouette.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": false }, { "code": "difficult_exit", "name": "Schwieriger Ausgang", "description": "Schwieriger Ausgang aus der Pirouette.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": false }, { "code": "change_of_edge", "name": "Klare Kantenänderung", "description": "Klare Kantenänderung in Sit, Camel, Layback, Biellmann oder schwieriger Upright-Variation.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "both_directions", "name": "Beide Richtungen", "description": "Beide Drehrichtungen unmittelbar nacheinander in Sit, Camel, Layback oder schwieriger Upright-Variation.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "increase_speed", "name": "Klare Temposteigerung", "description": "Klare Temposteigerung in Camel, Sit, Layback, Biellmann oder schwieriger Upright-Variation (nicht Crossfoot).", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "eight_revolutions", "name": "8 Umdrehungen ohne Wechsel", "description": "Mindestens 8 Umdrehungen ohne Wechsel von Position, Variation, Fuß oder Kante.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "difficult_flying_entry", "name": "Schwieriger Flug-Eingang", "description": "Schwierige Variation des fliegenden Eingangs bei Flugpirouetten.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": false }, { "code": "difficult_blade", "name": "Schwieriges Klingenmerkmal", "description": "Schwieriges Klingenmerkmal in Camel, Sit, Layback, Biellmann oder schwieriger Upright-Variation.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "layback_change", "name": "Layback-Positionswechsel", "description": "Layback: klarer Wechsel rückwärts-seitwärts oder umgekehrt, mindestens 2 Umdrehungen je Position.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "layback_biellmann", "name": "Biellmann nach Layback", "description": "Layback: Biellmann-Position nach dem Layback (SP 8 Umdrehungen, Advanced Novice 6).", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true } ] }, "sequence": { - "required_features": ["variety_of_turns"], + "required_features": [ + "variety_of_turns" + ], "level4_requires_any": [], "features": [ { diff --git a/rinkplanner/src/core/rules/data/2025-26/sov.json b/rinkplanner/src/core/rules/data/2025-26/sov.json index b087542..5e92c9b 100644 --- a/rinkplanner/src/core/rules/data/2025-26/sov.json +++ b/rinkplanner/src/core/rules/data/2025-26/sov.json @@ -159,7 +159,8 @@ "2": 1.5, "3": 1.9, "4": 2.4 - } + }, + "change_of_foot": false }, { "code": "LSp", @@ -171,7 +172,8 @@ "2": 1.9, "3": 2.4, "4": 2.7 - } + }, + "change_of_foot": false }, { "code": "CSp", @@ -183,7 +185,8 @@ "2": 1.8, "3": 2.3, "4": 2.6 - } + }, + "change_of_foot": false }, { "code": "SSp", @@ -195,7 +198,8 @@ "2": 1.6, "3": 2.1, "4": 2.5 - } + }, + "change_of_foot": false }, { "code": "FUSp", @@ -207,7 +211,8 @@ "2": 2.0, "3": 2.4, "4": 2.9 - } + }, + "change_of_foot": false }, { "code": "FLSp", @@ -219,7 +224,8 @@ "2": 2.4, "3": 2.9, "4": 3.2 - } + }, + "change_of_foot": false }, { "code": "FCSp", @@ -231,7 +237,8 @@ "2": 2.3, "3": 2.8, "4": 3.2 - } + }, + "change_of_foot": false }, { "code": "FSSp", @@ -243,7 +250,8 @@ "2": 2.3, "3": 2.6, "4": 3.0 - } + }, + "change_of_foot": false }, { "code": "CUSp", @@ -255,7 +263,8 @@ "2": 2.0, "3": 2.4, "4": 2.9 - } + }, + "change_of_foot": true }, { "code": "FCUSp", @@ -267,7 +276,8 @@ "2": 2.0, "3": 2.4, "4": 2.9 - } + }, + "change_of_foot": true }, { "code": "CLSp", @@ -279,7 +289,8 @@ "2": 2.4, "3": 2.9, "4": 3.2 - } + }, + "change_of_foot": true }, { "code": "FCLSp", @@ -291,7 +302,8 @@ "2": 2.4, "3": 2.9, "4": 3.2 - } + }, + "change_of_foot": true }, { "code": "CoSp", @@ -303,7 +315,8 @@ "2": 2.0, "3": 2.5, "4": 3.0 - } + }, + "change_of_foot": false }, { "code": "FCoSp", @@ -315,7 +328,8 @@ "2": 2.0, "3": 2.5, "4": 3.0 - } + }, + "change_of_foot": false }, { "code": "CCoSp", @@ -327,7 +341,8 @@ "2": 2.5, "3": 3.0, "4": 3.5 - } + }, + "change_of_foot": true }, { "code": "FCCoSp", @@ -339,7 +354,8 @@ "2": 2.5, "3": 3.0, "4": 3.5 - } + }, + "change_of_foot": true }, { "code": "StSq", diff --git a/rinkplanner/src/core/rules/data/2026-27/levels.json b/rinkplanner/src/core/rules/data/2026-27/levels.json index 8bab9a0..8010115 100644 --- a/rinkplanner/src/core/rules/data/2026-27/levels.json +++ b/rinkplanner/src/core/rules/data/2026-27/levels.json @@ -28,6 +28,12 @@ }, "types": { "spin": { + "max_features_per_foot": 2, + "groups": { + "difficult_variation": { + "max_per_element": 2 + } + }, "required_features": [], "level4_requires_any": [ "difficult_exit", @@ -39,109 +45,161 @@ ], "features": [ { - "code": "difficult_variation", - "name": "Schwierige Variation", - "description": "Schwierige Variation einer Grundposition; höchstens zwei zählen pro Pirouette.", - "max_per_element": 2, - "once_per_program": false + "code": "difficult_variation_sit", + "name": "Schwierige Variation — Sitz", + "description": "Schwierige Variation in der Sitzposition. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" + }, + { + "code": "difficult_variation_camel", + "name": "Schwierige Variation — Camel", + "description": "Schwierige Variation in der Camelposition. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" + }, + { + "code": "difficult_variation_layback", + "name": "Schwierige Variation — Layback", + "description": "Schwierige Variation in der Laybackposition. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" + }, + { + "code": "difficult_variation_upright", + "name": "Schwierige Variation — Upright", + "description": "Schwierige Variation in einer aufrechten Position. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" + }, + { + "code": "difficult_variation_other", + "name": "Schwierige Variation — Sonstige", + "description": "Schwierige Variation außerhalb der Grundpositionen. Zählt pro Programm einmal.", + "max_per_element": 1, + "once_per_program": true, + "per_foot": true, + "group": "difficult_variation" }, { "code": "change_foot_jump", "name": "Fußwechsel per Sprung", "description": "Fußwechsel mit einem Sprung ausgeführt.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": false }, { "code": "jump_in_spin", "name": "Sprung in der Pirouette", "description": "Sprung innerhalb der Pirouette ohne Fußwechsel.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "difficult_position_change", "name": "Schwieriger Positionswechsel", "description": "Schwieriger Positionswechsel auf demselben Fuß.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "difficult_entrance", "name": "Schwieriger Eingang", "description": "Schwieriger Eingang in die Pirouette.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": false }, { "code": "difficult_exit", "name": "Schwieriger Ausgang", "description": "Schwieriger Ausgang aus der Pirouette.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": false }, { "code": "change_of_edge", "name": "Klare Kantenänderung", "description": "Klare Kantenänderung in Sit, Camel, Layback, Biellmann oder schwieriger Upright-Variation.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "both_directions", "name": "Beide Richtungen", "description": "Beide Drehrichtungen unmittelbar nacheinander in Sit, Camel, Layback oder schwieriger Upright-Variation.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "increase_speed", "name": "Klare Temposteigerung", "description": "Klare Temposteigerung in Camel, Sit, Layback, Biellmann oder schwieriger Upright-Variation (nicht Crossfoot).", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "eight_revolutions", "name": "8 Umdrehungen ohne Wechsel", "description": "Mindestens 8 Umdrehungen ohne Wechsel von Position, Variation, Fuß oder Kante.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "difficult_flying_entry", "name": "Schwieriger Flug-Eingang", "description": "Schwierige Variation des fliegenden Eingangs bei Flugpirouetten.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": false }, { "code": "difficult_blade", "name": "Schwieriges Klingenmerkmal", "description": "Schwieriges Klingenmerkmal in Camel, Sit, Layback, Biellmann oder schwieriger Upright-Variation.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "windmills", "name": "Windmills", "description": "Windmills, dreimal hintereinander; jede Bewegung nahe am Spagat (mind. 135°). Zählt einmal pro Programm.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "layback_change", "name": "Layback-Positionswechsel", "description": "Layback: klarer Wechsel rückwärts-seitwärts oder umgekehrt, mindestens 2 Umdrehungen je Position.", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true }, { "code": "layback_biellmann", "name": "Biellmann nach Layback", "description": "Layback: Biellmann-Position nach dem Layback (SP 8 Umdrehungen, Advanced Novice 6).", "max_per_element": 1, - "once_per_program": true + "once_per_program": true, + "per_foot": true } ] }, diff --git a/rinkplanner/src/core/rules/data/2026-27/sov.json b/rinkplanner/src/core/rules/data/2026-27/sov.json index 8880cf7..1e3c49d 100644 --- a/rinkplanner/src/core/rules/data/2026-27/sov.json +++ b/rinkplanner/src/core/rules/data/2026-27/sov.json @@ -159,7 +159,8 @@ "2": 1.8, "3": 2.3, "4": 2.9 - } + }, + "change_of_foot": false }, { "code": "LSp", @@ -171,7 +172,8 @@ "2": 2.3, "3": 2.9, "4": 3.2 - } + }, + "change_of_foot": false }, { "code": "CSp", @@ -183,7 +185,8 @@ "2": 2.2, "3": 2.8, "4": 3.1 - } + }, + "change_of_foot": false }, { "code": "SSp", @@ -195,7 +198,8 @@ "2": 1.9, "3": 2.5, "4": 3.0 - } + }, + "change_of_foot": false }, { "code": "FUSp", @@ -207,7 +211,8 @@ "2": 2.4, "3": 2.9, "4": 3.5 - } + }, + "change_of_foot": false }, { "code": "FLSp", @@ -219,7 +224,8 @@ "2": 2.9, "3": 3.5, "4": 3.8 - } + }, + "change_of_foot": false }, { "code": "FCSp", @@ -231,7 +237,8 @@ "2": 2.8, "3": 3.4, "4": 3.8 - } + }, + "change_of_foot": false }, { "code": "FSSp", @@ -243,7 +250,8 @@ "2": 2.8, "3": 3.1, "4": 3.6 - } + }, + "change_of_foot": false }, { "code": "CUSp", @@ -255,7 +263,8 @@ "2": 2.4, "3": 2.9, "4": 3.5 - } + }, + "change_of_foot": true }, { "code": "FCUSp", @@ -267,7 +276,8 @@ "2": 2.4, "3": 2.9, "4": 3.5 - } + }, + "change_of_foot": true }, { "code": "CLSp", @@ -279,7 +289,8 @@ "2": 2.9, "3": 3.5, "4": 3.8 - } + }, + "change_of_foot": true }, { "code": "FCLSp", @@ -291,7 +302,8 @@ "2": 2.9, "3": 3.5, "4": 3.8 - } + }, + "change_of_foot": true }, { "code": "CoSp", @@ -303,7 +315,8 @@ "2": 2.4, "3": 3.0, "4": 3.6 - } + }, + "change_of_foot": false }, { "code": "FCoSp", @@ -315,7 +328,8 @@ "2": 2.4, "3": 3.0, "4": 3.6 - } + }, + "change_of_foot": false }, { "code": "CCoSp", @@ -327,7 +341,8 @@ "2": 3.0, "3": 3.6, "4": 4.2 - } + }, + "change_of_foot": true }, { "code": "FCCoSp", @@ -339,7 +354,8 @@ "2": 3.0, "3": 3.6, "4": 4.2 - } + }, + "change_of_foot": true }, { "code": "StSq", @@ -367,7 +383,8 @@ "type": "spin", "base_values": { "1": 3.5 - } + }, + "change_of_foot": false } ] } diff --git a/rinkplanner/src/core/rules/element_catalog.gd b/rinkplanner/src/core/rules/element_catalog.gd index 5263ed9..978b2ba 100644 --- a/rinkplanner/src/core/rules/element_catalog.gd +++ b/rinkplanner/src/core/rules/element_catalog.gd @@ -281,6 +281,7 @@ func _parse_definition(entry: Dictionary) -> ElementDefinition: definition.code = code definition.display_name = str(entry.get("name", "")).strip_edges() definition.element_type = TYPE_BY_NAME[type_name] + definition.change_of_foot = bool(entry.get("change_of_foot", false)) if entry.has("base_values"): var values: Variant = entry["base_values"] diff --git a/rinkplanner/src/core/rules/element_definition.gd b/rinkplanner/src/core/rules/element_definition.gd index 4db0ceb..14bb9ad 100644 --- a/rinkplanner/src/core/rules/element_definition.gd +++ b/rinkplanner/src/core/rules/element_definition.gd @@ -13,6 +13,9 @@ const MAX_LEVEL := PathSegment.ELEMENT_MAX_LEVEL @export var code: String = "" @export var display_name: String = "" @export var element_type: PathSegment.ElementType = PathSegment.ElementType.NONE +## Spins only: true when the element includes a change of foot. The ISU caps +## the level features attained on one foot at two, which only matters here. +@export var change_of_foot: bool = false ## Base value per level. Key 0 is "Base", keys 1-4 are the graded levels. @export var base_values: Dictionary[int, float] = {} diff --git a/rinkplanner/src/core/rules/element_feature.gd b/rinkplanner/src/core/rules/element_feature.gd index d2f5478..e1b5d26 100644 --- a/rinkplanner/src/core/rules/element_feature.gd +++ b/rinkplanner/src/core/rules/element_feature.gd @@ -15,6 +15,12 @@ extends Resource @export var max_per_element: int = 1 ## Only the first attempt in a program counts. Not enforced per element yet. @export var once_per_program: bool = true +## True when the feature is attained on one foot (variations, edges, speed …). +## Only those count toward the ISU cap of two features per foot in a spin with +## a change of foot. +@export var per_foot: bool = false +## Optional feature group (e.g. the difficult variations) with a shared cap. +@export var group: String = "" func validate() -> PackedStringArray: diff --git a/rinkplanner/src/core/rules/element_level_rules.gd b/rinkplanner/src/core/rules/element_level_rules.gd index 6ff9c94..42a1993 100644 --- a/rinkplanner/src/core/rules/element_level_rules.gd +++ b/rinkplanner/src/core/rules/element_level_rules.gd @@ -46,6 +46,8 @@ var _features_by_code: Dictionary[int, Dictionary] = {} var _required_by_type: Dictionary[int, PackedStringArray] = {} var _level4_by_type: Dictionary[int, PackedStringArray] = {} var _fixed_levels: Dictionary[String, int] = {} +var _groups_by_type: Dictionary[int, Dictionary] = {} +var _max_per_foot: Dictionary[int, int] = {} var _errors: PackedStringArray = PackedStringArray() @@ -111,13 +113,36 @@ func get_thresholds() -> Array[Dictionary]: return copy -## Evaluates the selected feature codes for one element. Unknown features and -## over-limit repetitions are reported in [member LevelResult.ignored_features] -## instead of raising the level. A fixed-level element (ChSq) short-circuits. +## Maximum number of features that count per foot in an element with a change +## of foot, or 0 when the season does not cap it. +func get_max_features_per_foot(type: PathSegment.ElementType) -> int: + return _max_per_foot.get(type, 0) + + +## Maximum number of features from one group (e.g. two difficult variations), +## or 0 when the group is unknown or unlimited. +func get_group_max(type: PathSegment.ElementType, group: String) -> int: + if not _groups_by_type.has(type): + return 0 + var groups: Dictionary = _groups_by_type[type] + if not groups.has(group): + return 0 + return int((groups[group] as Dictionary).get("max_per_element", 0)) + + +## Evaluates the selected feature codes for one element. Unknown features, +## over-limit repetitions, group overflows and per-foot overflows are reported +## in [member LevelResult.ignored_features] instead of raising the level. A +## fixed-level element (ChSq) short-circuits. +## +## [param feet] maps a feature code to the foot it was performed on ("L"/"R"). +## It is only needed for elements with a change of foot; features without an +## entry count as foot-neutral. func calculate_level( type: PathSegment.ElementType, code: String, - features: PackedStringArray + features: PackedStringArray, + feet: Dictionary = {} ) -> LevelResult: var result := LevelResult.new() var key := _normalize(code) @@ -132,6 +157,7 @@ func calculate_level( var definitions: Dictionary = _features_by_code[type] var counts: Dictionary[String, int] = {} + var accepted: Array[ElementFeature] = [] for raw: String in features: var feature_code := _normalize(raw) if feature_code.is_empty(): @@ -145,10 +171,17 @@ func calculate_level( _append_unique(result.ignored_features, raw) continue counts[feature_code] = used + 1 - result.counted_features += 1 + accepted.append(feature) + var counted := _apply_group_caps(type, accepted, result) + counted = _apply_foot_caps(type, counted, feet, result) + result.counted_features = counted.size() + + var counted_codes: Dictionary[String, int] = {} + for feature: ElementFeature in counted: + counted_codes[_normalize(feature.code)] = 1 for required: String in _required_by_type.get(type, PackedStringArray()): - if not counts.has(required): + if not counted_codes.has(_normalize(required)): result.missing_required.append(required) if not result.missing_required.is_empty(): @@ -160,11 +193,66 @@ func calculate_level( type, PackedStringArray() ) - if not level4_features.is_empty() and not _contains_any(counts, level4_features): + if not level4_features.is_empty() and not _contains_any( + counted_codes, + level4_features + ): result.level = MAX_LEVEL - 1 return result +## Drops features that exceed the cap of their group (e.g. at most two +## difficult variations per spin). +func _apply_group_caps( + type: PathSegment.ElementType, + accepted: Array[ElementFeature], + result: LevelResult +) -> Array[ElementFeature]: + var groups: Dictionary = _groups_by_type.get(type, {}) + if groups.is_empty(): + return accepted + var used: Dictionary[String, int] = {} + var kept: Array[ElementFeature] = [] + for feature: ElementFeature in accepted: + if not feature.group.is_empty() and groups.has(feature.group): + var maximum := int( + (groups[feature.group] as Dictionary).get("max_per_element", 0) + ) + var count: int = used.get(feature.group, 0) + if maximum > 0 and count >= maximum: + _append_unique(result.ignored_features, feature.code) + continue + used[feature.group] = count + 1 + kept.append(feature) + return kept + + +## ISU 2788: in a spin with a change of foot at most two features per foot +## count. Features without a foot entry stay neutral and are not capped. +func _apply_foot_caps( + type: PathSegment.ElementType, + accepted: Array[ElementFeature], + feet: Dictionary, + result: LevelResult +) -> Array[ElementFeature]: + var maximum := get_max_features_per_foot(type) + if maximum <= 0: + return accepted + var used: Dictionary[String, int] = {} + var kept: Array[ElementFeature] = [] + for feature: ElementFeature in accepted: + if feature.per_foot: + var foot := str(feet.get(feature.code, "")).strip_edges().to_upper() + if foot == "L" or foot == "R": + var count: int = used.get(foot, 0) + if count >= maximum: + _append_unique(result.ignored_features, feature.code) + continue + used[foot] = count + 1 + kept.append(feature) + return kept + + ## Checks a feature selection for unknown codes and over-limit repetitions. ## Missing required features are reported when the selection is non-empty. func validate_selection( @@ -319,6 +407,19 @@ func _parse_type(type: PathSegment.ElementType, data: Dictionary) -> void: _required_by_type[type] = _to_string_array(required as Array) if typeof(level4) == TYPE_ARRAY: _level4_by_type[type] = _to_string_array(level4 as Array) + var groups: Variant = data.get("groups", {}) + if typeof(groups) == TYPE_DICTIONARY: + var parsed_groups: Dictionary = {} + for group_name: Variant in groups as Dictionary: + var group_entry: Variant = (groups as Dictionary)[group_name] + if typeof(group_entry) != TYPE_DICTIONARY: + _errors.append("feature group '%s' must be an object" % group_name) + continue + parsed_groups[str(group_name)] = group_entry + _groups_by_type[type] = parsed_groups + var max_per_foot := int(data.get("max_features_per_foot", 0)) + if max_per_foot > 0: + _max_per_foot[type] = max_per_foot if typeof(features) != TYPE_ARRAY: _errors.append("'features' must be an array") return @@ -356,6 +457,8 @@ func _parse_feature(entry: Dictionary) -> ElementFeature: feature.description = str(entry.get("description", "")).strip_edges() feature.max_per_element = int(entry.get("max_per_element", 1)) feature.once_per_program = bool(entry.get("once_per_program", true)) + feature.per_foot = bool(entry.get("per_foot", false)) + feature.group = str(entry.get("group", "")).strip_edges() for message: String in feature.validate(): _errors.append("%s: %s" % [feature.code, message]) diff --git a/rinkplanner/src/core/rules/routine_validator.gd b/rinkplanner/src/core/rules/routine_validator.gd index e8ef84c..b25e8ed 100644 --- a/rinkplanner/src/core/rules/routine_validator.gd +++ b/rinkplanner/src/core/rules/routine_validator.gd @@ -545,9 +545,115 @@ func _validate_segment( _pass(report, "level") _validate_features(segment, code, section_id, report) + _validate_feature_feet(segment, code, section_id, report) _validate_jump_sequence(segment, section_id, report) +## ISU 2788: in a spin with a change of foot at most two features per foot +## count. Only elements whose catalog entry says so are checked. +func _validate_feature_feet( + segment: PathSegment, + code: String, + section_id: String, + report: ValidationReport +) -> void: + if segment.element_features.is_empty(): + return + if segment.element_type != PathSegment.ElementType.SPIN: + return + var definition := _catalog.find(code) if _catalog != null else null + if definition == null or not definition.change_of_foot: + return + + var per_foot_codes := PackedStringArray() + var missing_foot := PackedStringArray() + var per_foot: Dictionary[String, int] = {} + for raw: String in segment.element_features: + var feature_code := raw.strip_edges() + var feature := _rules.get_feature(segment.element_type, feature_code) + if feature == null or not feature.per_foot: + continue + per_foot_codes.append(feature_code) + var foot := str( + segment.element_feature_feet.get(feature_code, "") + ).strip_edges().to_upper() + if foot != "L" and foot != "R": + missing_foot.append(feature_code) + continue + per_foot[foot] = per_foot.get(foot, 0) + 1 + + # Without attribution the cap cannot be checked – but it only matters when + # more than two per-foot features are selected. + var maximum := _rules.get_max_features_per_foot(segment.element_type) + if not missing_foot.is_empty() and per_foot_codes.size() > maximum: + _append( + report, + ValidationIssue.Severity.WARNING, + I18n.t( + "Fuß nicht angegeben für „%s“; max. zwei Features pro Fuß sind nicht prüfbar." + ) % ", ".join(missing_foot), + section_id, + segment.segment_id + ) + _fail(report, "features", false) + + for foot: String in per_foot: + if per_foot[foot] <= maximum: + continue + _append( + report, + ValidationIssue.Severity.WARNING, + I18n.t("„%s“: %d Features auf einem Fuß, es zählen höchstens %d.") + % [ + code, + per_foot[foot], + maximum, + ], + section_id, + segment.segment_id + ) + _fail(report, "features", false) + + +## Reports features that exceed their group cap (e.g. a third difficult +## variation in one spin). Returns true when something was reported. +func _check_feature_groups( + segment: PathSegment, + code: String, + counts: Dictionary[String, int], + section_id: String, + report: ValidationReport +) -> bool: + var used: Dictionary[String, int] = {} + var failed := false + for feature_code: String in counts: + var feature := _rules.get_feature(segment.element_type, feature_code) + if feature == null or feature.group.is_empty(): + continue + var maximum := _rules.get_group_max( + segment.element_type, + feature.group + ) + if maximum <= 0: + continue + var count: int = used.get(feature.group, 0) + int(counts[feature_code]) + used[feature.group] = count + for group: String in used: + var maximum := _rules.get_group_max(segment.element_type, group) + if maximum <= 0 or used[group] <= maximum: + continue + _append( + report, + ValidationIssue.Severity.WARNING, + I18n.t("Bei „%s“ zählen höchstens %d Features der Gruppe „%s“.") + % [code, maximum, group], + section_id, + segment.segment_id + ) + failed = true + return failed + + func _validate_features( segment: PathSegment, code: String, @@ -609,6 +715,15 @@ func _validate_features( continue counts[feature_code] = used + 1 + if not feature_failed: + feature_failed = _check_feature_groups( + segment, + code, + counts, + section_id, + report + ) + if feature_failed: _fail(report, "features", true) else: @@ -650,7 +765,8 @@ func _validate_features( var result := _rules.calculate_level( segment.element_type, code, - segment.element_features + segment.element_features, + segment.element_feature_feet ) if not result.missing_required.is_empty(): return diff --git a/rinkplanner/src/core/rules/season_upgrade_check.gd b/rinkplanner/src/core/rules/season_upgrade_check.gd index 0fe3cd2..f6e34c7 100644 --- a/rinkplanner/src/core/rules/season_upgrade_check.gd +++ b/rinkplanner/src/core/rules/season_upgrade_check.gd @@ -168,7 +168,8 @@ static func _check_element( var result := target.levels.calculate_level( segment.element_type, code, - segment.element_features + segment.element_features, + segment.element_feature_feet ) if result.level != segment.element_level: _add( diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index 457bfa1..2414d99 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -221,6 +221,8 @@ const UPDATE_FILE_NAMES := { @onready var jump_sequence_hint: Label = %JumpSequenceHint @onready var element_features_button: Button = %ElementFeaturesButton @onready var element_feature_hint: Label = %ElementFeatureHint +@onready var spin_foot_hint: Label = %SpinFootHint +@onready var spin_foot_panel: VBoxContainer = %SpinFootPanel @onready var element_feature_menu: PopupMenu = %ElementFeatureMenu @onready var validation_button: Button = %ValidationButton @onready var season_option: OptionButton = %SeasonOption @@ -341,6 +343,7 @@ var _rules_library: RulesLibrary var _rules_package: RulesPackage var _default_season: String = "" var _dialog_features: PackedStringArray = PackedStringArray() +var _dialog_feature_feet: Dictionary[String, String] = {} var _dialog_jump_kind: PathSegment.JumpKind = PathSegment.JumpKind.SOLO var _dialog_combination_jumps: PackedStringArray = PackedStringArray() var _show_score_info: bool = false @@ -1622,25 +1625,34 @@ func get_selected_element_features() -> PackedStringArray: ## Replaces the feature selection of the selected element and, for catalog ## elements, the derived level. Returns true when the model changed. -func set_selected_element_features(features: PackedStringArray) -> bool: +func set_selected_element_features( + features: PackedStringArray, + feet: Dictionary = {} +) -> bool: var segment := get_selected_element_lead() if segment == null or not segment.is_element(): return false var cleaned := _clean_feature_codes(features) + var cleaned_feet := _clean_feature_feet(cleaned, feet) var derived := _is_derived_level(segment.element_type, segment.element_code) var new_level := segment.element_level if derived: new_level = _derived_level( segment.element_type, segment.element_code, - cleaned + cleaned, + cleaned_feet ) - if segment.element_features == cleaned and segment.element_level == new_level: + if ( + segment.element_features == cleaned + and segment.element_feature_feet == cleaned_feet + and segment.element_level == new_level + ): return false _record_undo() - segment.set_element_features(cleaned) + segment.set_element_features(cleaned, cleaned_feet) if derived: segment.element_level = new_level if element_dialog.visible: @@ -1692,7 +1704,12 @@ func update_element_feature_hint() -> void: element_feature_hint.text = "Kürzel nicht im Katalog." return - var result := _level_rules.calculate_level(type, code, features) + var result := _level_rules.calculate_level( + type, + code, + features, + _dialog_feature_feet + ) element_features_button.disabled = false element_features_button.text = "Features (%d)" % result.counted_features @@ -1811,9 +1828,104 @@ func _on_feature_menu_hidden() -> void: ): features.append(str(element_feature_menu.get_item_metadata(index))) _dialog_features = _clean_feature_codes(features) + _dialog_feature_feet = _clean_feature_feet( + _dialog_features, + _dialog_feature_feet + ) _update_level_control_state() update_element_feature_hint() update_element_value_hint() + _update_feature_foot_panel() + + +## Shows the foot selector only when it can change the result: a spin with a +## change of foot whose selected per-foot features exceed the ISU cap of two. +func _update_feature_foot_panel() -> void: + if spin_foot_panel == null or spin_foot_hint == null: + return + for child: Node in spin_foot_panel.get_children(): + spin_foot_panel.remove_child(child) + child.free() + + var per_foot: Array[ElementFeature] = [] + if _level_rules != null and _element_catalog != null: + var definition := _element_catalog.find(_dialog_element_code()) + if ( + definition != null + and definition.element_type == PathSegment.ElementType.SPIN + and definition.change_of_foot + ): + for feature: ElementFeature in _level_rules.get_features( + PathSegment.ElementType.SPIN + ): + if feature.per_foot and _dialog_features.has(feature.code): + per_foot.append(feature) + + var maximum := 0 + if _level_rules != null: + maximum = _level_rules.get_max_features_per_foot( + PathSegment.ElementType.SPIN + ) + var needed := maximum > 0 and per_foot.size() > maximum + spin_foot_panel.visible = needed + spin_foot_hint.visible = needed + if not needed: + return + + for feature: ElementFeature in per_foot: + var row := HBoxContainer.new() + row.add_theme_constant_override("separation", 4) + var label := Label.new() + label.text = feature.display_name + label.size_flags_horizontal = Control.SIZE_EXPAND_FILL + label.add_theme_font_size_override("font_size", 13) + row.add_child(label) + row.add_child(_foot_button(feature.code, "L")) + row.add_child(_foot_button(feature.code, "R")) + spin_foot_panel.add_child(row) + + if element_dialog != null and element_dialog.visible: + element_dialog.size = Vector2i(520, 460 + per_foot.size() * 44 + 40) + + +func _foot_button(code: String, foot: String) -> Button: + var button := Button.new() + button.text = I18n.t("Links") if foot == "L" else I18n.t("Rechts") + button.toggle_mode = true + button.custom_minimum_size = Vector2(72, 40) + button.button_pressed = _dialog_feature_feet.get(code, "") == foot + button.set_meta("feature_code", code) + button.set_meta("foot", foot) + button.pressed.connect(_on_feature_foot_pressed.bind(code, foot)) + return button + + +func _on_feature_foot_pressed(code: String, foot: String) -> void: + if _dialog_feature_feet.get(code, "") == foot: + _dialog_feature_feet.erase(code) + else: + _dialog_feature_feet[code] = foot + _refresh_foot_buttons() + _update_level_control_state() + update_element_feature_hint() + update_element_value_hint() + + +## Refreshes the pressed state of the foot buttons without rebuilding them: +## the callback runs from one of these buttons. +func _refresh_foot_buttons() -> void: + if spin_foot_panel == null: + return + for row: Node in spin_foot_panel.get_children(): + for child: Node in row.get_children(): + if not child is Button: + continue + var button := child as Button + var code := str(button.get_meta("feature_code", "")) + var foot := str(button.get_meta("foot", "")) + button.set_pressed_no_signal( + _dialog_feature_feet.get(code, "") == foot + ) ## Updates the Base-Value hint in the element inspector. Public so tests and @@ -1932,13 +2044,27 @@ func _is_derived_level( func _derived_level( type: PathSegment.ElementType, code: String, - features: PackedStringArray + features: PackedStringArray, + feet: Dictionary = {} ) -> int: if type == PathSegment.ElementType.JUMP: return 0 if _level_rules == null: return 0 - return _level_rules.calculate_level(type, code, features).level + return _level_rules.calculate_level(type, code, features, feet).level + + +## Keeps only the feet of selected features and normalises them to L/R. +func _clean_feature_feet( + features: PackedStringArray, + feet: Dictionary +) -> Dictionary[String, String]: + var cleaned: Dictionary[String, String] = {} + for code: String in features: + var foot := str(feet.get(code, "")).strip_edges().to_upper() + if foot == "L" or foot == "R": + cleaned[code] = foot + return cleaned func _update_level_control_state() -> void: @@ -1958,7 +2084,7 @@ func _update_level_control_state() -> void: ) if derived: _select_level_option( - _derived_level(type, code, _dialog_features) + _derived_level(type, code, _dialog_features, _dialog_feature_feet) ) @@ -2293,7 +2419,8 @@ func set_selected_element_with_features( jump_kind: PathSegment.JumpKind = PathSegment.JumpKind.SOLO, combination_jumps: PackedStringArray = PackedStringArray(), revolutions: float = -1.0, - rotation_direction: int = -1 + rotation_direction: int = -1, + feet: Dictionary = {} ) -> bool: var element := get_selected_element() var segment := element.get_lead() if element != null else get_selected_segment() @@ -2322,6 +2449,7 @@ func set_selected_element_with_features( var cleaned := code.strip_edges().left(PathSegment.ELEMENT_CODE_MAX_LENGTH) var clamped := clampi(level, 0, PathSegment.ELEMENT_MAX_LEVEL) var cleaned_features := _clean_feature_codes(features) + var cleaned_feet := _clean_feature_feet(cleaned_features, feet) var cleaned_kind := jump_kind var cleaned_combination := _clean_jump_combination(combination_jumps) if type != PathSegment.ElementType.JUMP: @@ -2334,7 +2462,7 @@ func set_selected_element_with_features( cleaned = str(normalized["code"]) clamped = int(normalized["level"]) if _is_derived_level(type, cleaned): - clamped = _derived_level(type, cleaned, cleaned_features) + clamped = _derived_level(type, cleaned, cleaned_features, cleaned_feet) if ( type == PathSegment.ElementType.JUMP and cleaned_combination.is_empty() @@ -2356,6 +2484,7 @@ func set_selected_element_with_features( cleaned = "" clamped = 0 cleaned_features = PackedStringArray() + cleaned_feet = {} cleaned_kind = PathSegment.JumpKind.SOLO cleaned_combination = PackedStringArray() clamped_duration = 0.0 @@ -2413,6 +2542,7 @@ func set_selected_element_with_features( and segment.element_code == cleaned and segment.element_level == clamped and segment.element_features == cleaned_features + and segment.element_feature_feet == cleaned_feet and segment.jump_kind == cleaned_kind and segment.combination_jumps == cleaned_combination and segment.element_duration_seconds == clamped_duration @@ -2425,7 +2555,7 @@ func set_selected_element_with_features( if type == PathSegment.ElementType.NONE: segment.element_group_id = "" segment.set_element(type, cleaned, clamped) - segment.set_element_features(cleaned_features) + segment.set_element_features(cleaned_features, cleaned_feet) segment.set_jump_combination(cleaned_kind, cleaned_combination) segment.set_element_duration(maxf(clamped_duration, 0.0)) segment.set_element_revolutions(clamped_revolutions) @@ -3162,6 +3292,7 @@ func _on_element_code_text_changed(_text: String) -> void: _update_level_control_state() update_element_feature_hint() update_element_value_hint() + _update_feature_foot_panel() func _on_element_value_option_selected(_index: int) -> void: @@ -3206,6 +3337,7 @@ func _open_element_dialog() -> void: type_index = 0 element_dialog_type_option.select(type_index) _dialog_features = segment.element_features.duplicate() + _dialog_feature_feet = segment.element_feature_feet.duplicate() _dialog_jump_kind = segment.jump_kind _dialog_combination_jumps = segment.combination_jumps.duplicate() jump_kind_option.select( @@ -3262,6 +3394,7 @@ func _open_element_dialog() -> void: element_code_option.grab_focus() update_element_value_hint() update_element_feature_hint() + _update_feature_foot_panel() func _on_element_confirmed() -> void: @@ -3278,7 +3411,8 @@ func _on_element_confirmed() -> void: _dialog_jump_kind, _dialog_combination_jumps, element_revolutions_spin.value, - element_rotation_option.get_item_id(element_rotation_option.selected) + element_rotation_option.get_item_id(element_rotation_option.selected), + _dialog_feature_feet ) diff --git a/rinkplanner/tests/manual/capture_elements.gd b/rinkplanner/tests/manual/capture_elements.gd index 920345a..ea057a5 100644 --- a/rinkplanner/tests/manual/capture_elements.gd +++ b/rinkplanner/tests/manual/capture_elements.gd @@ -86,7 +86,7 @@ func _capture() -> void: elif args.size() > 3 and args[3] == "features": controller.select_segment(spin.segment_id) controller.set_selected_element_features( - PackedStringArray(["difficult_variation", "difficult_exit"]) + PackedStringArray(["difficult_variation_sit", "difficult_exit"]) ) controller.element_button.pressed.emit() elif args.size() > 3 and args[3] == "validate": diff --git a/rinkplanner/tests/run_level_tests.gd b/rinkplanner/tests/run_level_tests.gd index 674438a..5caee19 100644 --- a/rinkplanner/tests/run_level_tests.gd +++ b/rinkplanner/tests/run_level_tests.gd @@ -27,6 +27,7 @@ func _init() -> void: _test_sequence_levels() _test_fixed_and_unlevelled_elements() _test_feature_validation() + _test_foot_cap() _test_segment_features() _finish() @@ -42,8 +43,8 @@ func _test_rules_metadata() -> void: _check(_rules.source.contains("2788"), "level rules name ISU communication 2788") _check(_rules.valid_from == "2026-06-01", "level rules valid from 2026-06-01") _check( - _rules.get_features(PathSegment.ElementType.SPIN).size() == 15, - "spin rules contain 15 features" + _rules.get_features(PathSegment.ElementType.SPIN).size() == 19, + "spin rules contain 19 features (five variation categories)" ) _check( _rules.get_features(PathSegment.ElementType.SEQUENCE).size() == 5, @@ -56,11 +57,16 @@ func _test_rules_metadata() -> void: var variation: ElementFeature = _rules.get_feature( PathSegment.ElementType.SPIN, - "difficult_variation" + "difficult_variation_sit" ) _check(variation != null, "difficult variation exists") - _check(variation.max_per_element == 2, "difficult variation counts twice") - _check(not variation.once_per_program, "difficult variation is not once-only") + _check(variation.max_per_element == 1, "a variation counts once per element") + _check(variation.once_per_program, "a variation counts once per program") + _check(variation.per_foot, "a variation is attained on one foot") + _check( + variation.group == "difficult_variation", + "variations share a group" + ) var exit: ElementFeature = _rules.get_feature( PathSegment.ElementType.SPIN, "difficult_exit" @@ -75,14 +81,14 @@ func _test_spin_levels() -> void: _check_level( spins, "CCoSp", - PackedStringArray(["difficult_variation"]), + PackedStringArray(["difficult_variation_sit"]), 1, "one feature gives Level 1" ) _check_level( spins, "CCoSp", - PackedStringArray(["difficult_variation", "difficult_variation"]), + PackedStringArray(["difficult_variation_sit", "difficult_variation_camel"]), 2, "two difficult variations give Level 2" ) @@ -90,7 +96,7 @@ func _test_spin_levels() -> void: spins, "CCoSp", PackedStringArray( - ["difficult_variation", "difficult_variation", "difficult_variation"] + ["difficult_variation_sit", "difficult_variation_camel", "difficult_variation_layback"] ), 2, "a third difficult variation is ignored" @@ -100,8 +106,7 @@ func _test_spin_levels() -> void: "CCoSp", PackedStringArray( [ - "difficult_variation", - "difficult_variation", + "difficult_variation_sit", "difficult_variation_camel", "difficult_exit", "change_of_edge", ] @@ -114,8 +119,7 @@ func _test_spin_levels() -> void: "CCoSp", PackedStringArray( [ - "difficult_variation", - "difficult_variation", + "difficult_variation_sit", "difficult_variation_camel", "change_foot_jump", "jump_in_spin", ] @@ -233,12 +237,82 @@ func _test_fixed_and_unlevelled_elements() -> void: ) +func _test_foot_cap() -> void: + var spins := PathSegment.ElementType.SPIN + var features := PackedStringArray( + [ + "difficult_variation_sit", + "difficult_variation_camel", + "change_of_edge", + ] + ) + + var one_foot := _rules.calculate_level( + spins, + "CCoSp", + features, + { + "difficult_variation_sit": "L", + "difficult_variation_camel": "L", + "change_of_edge": "L", + } + ) + _check( + one_foot.counted_features == 2, + "only two features on one foot count (%d)" % one_foot.counted_features + ) + _check(one_foot.level == 2, "the per-foot cap lowers the level") + + var both_feet := _rules.calculate_level( + spins, + "CCoSp", + features, + { + "difficult_variation_sit": "L", + "difficult_variation_camel": "R", + "change_of_edge": "R", + } + ) + _check( + both_feet.counted_features == 3, + "features on two feet all count (%d)" % both_feet.counted_features + ) + _check(both_feet.level == 3, "three counted features give Level 3") + + var unattributed := _rules.calculate_level(spins, "CCoSp", features, {}) + _check( + unattributed.counted_features == 3, + "unattributed features are not capped" + ) + + var group := _rules.calculate_level( + spins, + "CCoSp", + PackedStringArray( + [ + "difficult_variation_sit", + "difficult_variation_camel", + "difficult_variation_layback", + ] + ), + { + "difficult_variation_sit": "L", + "difficult_variation_camel": "R", + "difficult_variation_layback": "L", + } + ) + _check( + group.counted_features == 2, + "at most two difficult variations count per spin" + ) + + func _test_feature_validation() -> void: var spins := PathSegment.ElementType.SPIN _check( _rules.validate_selection( spins, - PackedStringArray(["difficult_variation", "difficult_exit"]) + PackedStringArray(["difficult_variation_sit", "difficult_exit"]) ).is_empty(), "a valid spin selection has no errors" ) @@ -254,10 +328,13 @@ func _test_feature_validation() -> void: _rules.validate_selection( spins, PackedStringArray( - ["difficult_variation", "difficult_variation", "difficult_variation"] + [ + "difficult_variation_sit", + "difficult_variation_sit", + ] ) ), - "more than 2 time(s)" + "more than 1 time(s)" ), "over-limit repetitions are reported" ) @@ -294,7 +371,7 @@ func _test_segment_features() -> void: marker.curve = _make_point_curve(Vector2.ZERO) marker.set_element(PathSegment.ElementType.SPIN, "CCoSp", 4) marker.set_element_features( - PackedStringArray(["difficult_variation", "difficult_variation", "difficult_exit"]) + PackedStringArray(["difficult_variation_sit", "difficult_variation_camel", "difficult_exit"]) ) _check(marker.element_features.size() == 3, "features are stored on the segment") _check(marker.is_valid(), "a segment with features is valid") diff --git a/rinkplanner/tests/run_validation_tests.gd b/rinkplanner/tests/run_validation_tests.gd index a41ab3f..f45a837 100644 --- a/rinkplanner/tests/run_validation_tests.gd +++ b/rinkplanner/tests/run_validation_tests.gd @@ -57,12 +57,16 @@ func _test_clean_routine() -> void: 4, PackedStringArray( [ - "difficult_variation", - "difficult_variation", + "difficult_variation_sit", "difficult_variation_camel", "difficult_exit", "change_of_edge", ] - ) + ), + { + "difficult_variation_sit": "L", + "difficult_variation_camel": "R", + "change_of_edge": "R", + } ) _add_marker( section, @@ -99,7 +103,7 @@ func _test_clean_routine() -> void: "the compulsory sequence feature was checked" ) _check(report.get_check("level_features").passed == 2, "both derived levels match") - _check(report.get_check("once").passed == 6, "once-per-program features were checked") + _check(report.get_check("once").passed == 8, "once-per-program features were checked") _check_approx( report.base_value_total, 8.30, @@ -332,15 +336,23 @@ func _test_feature_selection() -> void: "CCoSp", 0, PackedStringArray( - ["difficult_variation", "difficult_variation", "difficult_variation"] - ) + ["difficult_variation_sit", "difficult_variation_camel", "difficult_variation_layback"] + ), + { + "difficult_variation_sit": "L", + "difficult_variation_camel": "R", + "difficult_variation_layback": "L", + } ) var too_many := too_many_report.issues _check( - _count(too_many, ValidationIssueScript.Severity.ERROR) == 1, - "too many difficult variations is an error" + _count(too_many, ValidationIssueScript.Severity.WARNING) == 1, + "too many difficult variations is a warning (%s)" % _messages(too_many) + ) + _check( + _has_message(too_many, "höchstens 2 Features der Gruppe"), + "the group limit is named" ) - _check(_has_message(too_many, "zu oft"), "over-limit feature message") var missing_report := _report_one( PathSegment.ElementType.SEQUENCE, @@ -369,7 +381,7 @@ func _test_level_mismatch() -> void: PathSegment.ElementType.SPIN, "CCoSp", 4, - PackedStringArray(["difficult_variation", "difficult_exit"]) + PackedStringArray(["difficult_variation_sit", "difficult_exit"]) ) var issues := report.issues _check( @@ -483,10 +495,19 @@ func _report_one( type: PathSegment.ElementType, code: String, level: int, - features: PackedStringArray + features: PackedStringArray, + feet: Dictionary = {} ) -> ValidationReport: var routine := _make_routine() - _add_marker(routine.sections[0], "segment", type, code, level, features) + _add_marker( + routine.sections[0], + "segment", + type, + code, + level, + features, + feet + ) return _validator.validate_report(routine) @@ -509,7 +530,8 @@ func _add_marker( type: PathSegment.ElementType, code: String, level: int, - features: PackedStringArray + features: PackedStringArray, + feet: Dictionary = {} ) -> PathSegment: var segment: PathSegment = PathSegmentModel.new() segment.segment_id = segment_id @@ -517,7 +539,7 @@ func _add_marker( curve.add_point(Vector2.ZERO) segment.curve = curve segment.set_element(type, code, level) - segment.set_element_features(features) + segment.set_element_features(features, feet) section.segments.append(segment) return segment diff --git a/rinkplanner/tests/run_whiteboard_tests.gd b/rinkplanner/tests/run_whiteboard_tests.gd index f4268d8..5d4909e 100644 --- a/rinkplanner/tests/run_whiteboard_tests.gd +++ b/rinkplanner/tests/run_whiteboard_tests.gd @@ -978,8 +978,7 @@ func _run() -> void: controller.set_selected_element_features( PackedStringArray( [ - "difficult_variation", - "difficult_variation", + "difficult_variation_sit", "difficult_variation_camel", "difficult_exit", "change_of_edge", ] @@ -1052,7 +1051,7 @@ func _run() -> void: _select_dialog_code(controller, "CCoSp") _check( controller.set_selected_element_features( - PackedStringArray(["difficult_variation", "difficult_exit"]) + PackedStringArray(["difficult_variation_sit", "difficult_exit"]) ), "features update the derived level" ) @@ -1108,19 +1107,27 @@ func _run() -> void: "feature menu populates for a spin" ) _check( - controller.element_feature_menu.item_count == 18, - "feature menu lists 15 features plus the second difficult variation" + controller.element_feature_menu.item_count == 21, + "feature menu lists 19 features plus separator and reset" ) _check( - controller.element_feature_menu.get_item_metadata(0) == "difficult_variation", + controller.element_feature_menu.get_item_metadata(0) == "difficult_variation_sit", "feature menu items carry their feature code" ) _check( controller.element_feature_menu.is_item_checked(0), "the selected difficult variation is checked" ) + var exit_index := -1 + for index: int in range(controller.element_feature_menu.item_count): + if ( + str(controller.element_feature_menu.get_item_metadata(index)) + == "difficult_exit" + ): + exit_index = index _check( - controller.element_feature_menu.is_item_checked(6), + exit_index >= 0 + and controller.element_feature_menu.is_item_checked(exit_index), "the selected difficult exit is checked" ) controller.element_feature_menu.set_item_checked(1, false) @@ -1222,7 +1229,7 @@ func _run() -> void: _check(spin.element_level == 0, "clearing features resets the level to Base") _check( controller.set_selected_element_features( - PackedStringArray(["difficult_variation", "difficult_exit"]) + PackedStringArray(["difficult_variation_sit", "difficult_exit"]) ), "features restore Level 2" ) @@ -1837,7 +1844,45 @@ func _run() -> void: controller.new_routine() - # Structured jump combination in the element dialog. + # Fuß-Deckel: ab drei fußbezogenen Features fragt der Dialog nach dem Fuß. + var spin_segment := controller.add_element_marker( + Vector2(0.0, 0.0), + PathSegment.ElementType.SPIN, + "CCoSp", + 0 + ) + controller.select_segment(spin_segment.segment_id) + _check( + controller.set_selected_element_features( + PackedStringArray( + [ + "difficult_variation_sit", + "difficult_variation_camel", + "change_of_edge", + ] + ), + { + "difficult_variation_sit": "L", + "difficult_variation_camel": "R", + "change_of_edge": "R", + } + ), + "features with their foot are stored on the segment" + ) + _check( + spin_segment.element_feature_feet.size() == 3, + "the foot of each feature is stored" + ) + controller.element_button.pressed.emit() + _check( + controller.spin_foot_panel.visible, + "the foot selector appears for three per-foot features" + ) + _check( + controller.spin_foot_panel.get_child_count() == 3, + "one row per per-foot feature" + ) + controller.element_dialog.hide() controller.new_routine() var combo_marker := controller.add_element_marker( Vector2(0.0, 0.0),