From 1f5834752e6b0983cdbc0703e3cdd9f318e19341 Mon Sep 17 00:00:00 2001 From: torsten Date: Sat, 31 Oct 2026 10:42:55 +0100 Subject: [PATCH] feat: Level automatisch aus Features - Katalog-Pirouetten und -Sequenzen setzen element_level aus dem Feature-Ergebnis - Spruenge fest Base, ChSq fest Level 1 - Level-Regler bei Katalog-Elementen read-only - Unbekannte Freitext-Codes behalten den manuellen Level - Undo umfasst Feature- und Levelaenderung gemeinsam - Whiteboard-Tests auf 253 Assertions erweitert (912 gesamt) - Doku und Findings aktualisiert --- docs/architecture.md | 24 ++--- docs/findings-2026-10-31-isu-levels.md | 9 +- .../findings-2026-10-31-level-aus-features.md | 69 ++++++++++++++ docs/isu-rules.md | 22 +++-- docs/roadmap.md | 2 + .../whiteboard/ctrl/whiteboard_controller.gd | 95 ++++++++++++++++++- rinkplanner/tests/run_whiteboard_tests.gd | 90 +++++++++++++----- 7 files changed, 256 insertions(+), 55 deletions(-) create mode 100644 docs/findings-2026-10-31-level-aus-features.md diff --git a/docs/architecture.md b/docs/architecture.md index 34f0bb5..957ed73 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -3,8 +3,8 @@ Stand: 2026-10-31 Grundlage: `rinkplanner/rinkplanner_definition_agent_guidelines.md` Übergeordnete Reihenfolge: `docs/roadmap.md` -Letzte Session: `docs/findings-2026-10-31-kuerzelauswahl.md` -(Session davor: `docs/findings-2026-10-31-validierung.md`) +Letzte Session: `docs/findings-2026-10-31-level-aus-features.md` +(Session davor: `docs/findings-2026-10-31-kuerzelauswahl.md`) ## 1. Leitentscheidung @@ -123,14 +123,15 @@ ins Level-Feld normalisiert. Unbekannte Kürzel oder Level liefern `-1` statt einen stillen Standardwert. Das JSON wird über `include_filter="*.json"` in die Exporte aufgenommen. -**D9 – Level-Features sind Daten, das Level bleibt eine Autorengröße.** +**D9 – Level-Features sind Daten, der Level folgt aus ihnen.** `ElementLevelRules` liest eine eigene saisonale JSON-Datei mit Feature-Sätzen und Schwellen. Ausgewählte Features liegen als Codes am Segment (`element_features`); Duplikate sind erlaubt, damit z. B. zwei schwierige -Variationen zwei Features zählen. Der Inspector berechnet daraus ein Level -und zeigt es an, ersetzt aber das manuell gewählte `element_level` nicht -stillschweigend. So bleiben Altdaten und bewusste Overrides sichtbar, und die -spätere Validierung kann Abweichungen melden. +Variationen zwei Features zählen. Für Katalog-Elemente setzt der Controller +`element_level` automatisch aus dem Feature-Ergebnis; der Level-Regler ist +dann read-only. Sprünge sind fest Base, `ChSq` fest Level 1. Unbekannte +Freitext-Codes behalten einen manuellen Level als Fallback; die Validierung +meldet dort weiterhin Abweichungen. **D10 – Validierung liefert Befunde statt eines Ja/Nein.** `RoutineValidator` prüft Elementdaten gegen Katalog und Level-Regeln und @@ -191,9 +192,10 @@ Begrenzung auf zwei Features pro Fuß. außerdem den **Base Value** des eingegebenen Kürzels und Levels aus dem Saisonkatalog; unbekannte Kürzel werden als „nicht im Katalog“ markiert. Der Button **Features (n)** öffnet die Checkbox-Liste der Level-Features - (Pirouetten, Schrittsequenzen) und übernimmt die Auswahl undo-fähig. Ein - Hinweis zeigt Feature-Anzahl, abgeleitetes Level und eine Abweichung zum - gewählten Level; das gewählte Level bleibt autoritativ. + (Pirouetten, Schrittsequenzen) und übernimmt die Auswahl undo-fähig. Der + Level wird daraus automatisch gesetzt und der Level-Regler ist bei + Katalog-Elementen read-only; Sprünge sind fest Base, `ChSq` fest Level 1. + Ein Hinweis zeigt Feature-Anzahl und abgeleitetes Level. Die Timing-Details (Dauer/Tempo/Profil) werden beim Setzen und für Punktmarker ausgeblendet, damit die Leiste auch im Landscape kompakt bleibt. - **Prüfung:** Der Button „Prüfen“ in der Statusleiste validiert alle @@ -364,7 +366,7 @@ Aktueller Stand: Prüfstatistik je Kategorie. - **Canvas:** 90 Assertions für Meter→Pixel-Mapping, Fit/Zoom/Pan, Rink-Kontur und die reine Bogen-Geometrie. -- **Whiteboard:** 241 Assertions für Controller-Verdrahtung, Segmenterzeugung, +- **Whiteboard:** 253 Assertions für Controller-Verdrahtung, Segmenterzeugung, Linien-/Bogenpfade, Klemmen an der Bande, Auswahl, Griff- und Richtungs-/Kanten-Bearbeitung, Segmentlöschung, Element-Marker (Setzen, Typwechsel, Inspector inkl. Kürzelauswahl, Standzeit, Base-Value- und diff --git a/docs/findings-2026-10-31-isu-levels.md b/docs/findings-2026-10-31-isu-levels.md index 0671235..f98ee0a 100644 --- a/docs/findings-2026-10-31-isu-levels.md +++ b/docs/findings-2026-10-31-isu-levels.md @@ -41,10 +41,11 @@ Element-Inspector. Variationen als zwei Features zählen. Die Reihenfolge bleibt erhalten. - **Typwechsel leert die Auswahl.** Features sind typabhängig; `set_element` verwirft sie beim Wechsel des Elementtyps und beim Entfernen des Elements. -- **Das Level bleibt eine Autorengröße.** Die Berechnung erzeugt nur einen - Hinweis (`Features: 2 · Level 2 · gewählt: Level 4`). Der Inspector ändert - das gewählte Level nicht stillschweigend. So bleiben Altdaten und bewusste - Overrides sichtbar; die Validierung kann später Abweichungen melden. +- **Der Level folgt aus den Features.** Die Feature-Auswahl setzt + `element_level` für Katalog-Elemente automatisch; der Level-Regler ist dann + read-only. Sprünge sind fest Base, `ChSq` fest Level 1. Unbekannte + Freitext-Codes behalten einen manuellen Level als Fallback. (Ursprünglich + war der Level rein manuell; die Automatik kam im Folgeschritt.) - **Eigene JSON-Datei.** Level-Features stammen aus einer anderen Communication als die Base Values und ändern sich unabhängig. Beide Dateien tragen Saison, Quelle und Gültigkeitsdatum. diff --git a/docs/findings-2026-10-31-level-aus-features.md b/docs/findings-2026-10-31-level-aus-features.md new file mode 100644 index 0000000..a63751d --- /dev/null +++ b/docs/findings-2026-10-31-level-aus-features.md @@ -0,0 +1,69 @@ +# Findings – Session: Level aus Features (2026-10-31) + +Ergänzung zu `docs/findings-2026-10-31-kuerzelauswahl.md`. +Der Level war bisher eine freie Auswahl, während die Features nur einen +Hinweis erzeugten. Jetzt folgt der Level bei Katalog-Elementen automatisch aus +der Feature-Auswahl. + +## Ergebnis + +| Ziel | Ergebnis | +| :--- | :--- | +| Pirouetten/Sequenzen | Level = berechnetes Feature-Ergebnis | +| Sprünge | Level fest Base (0) | +| `ChSq` | Level fest 1 | +| Unbekannte Freitext-Codes | Level bleibt manuell | +| Oberfläche | Level-Regler bei Katalog-Elementen read-only | +| Undo | Feature- und Leveländerung in einem Schritt | +| Tests | 912 Assertions gesamt, `./tools/test.sh` grün | + +## Verhalten + +- `set_selected_element_features()` berechnet das Level neu und schreibt es + zusammen mit den Features in einem Undo-Schritt. +- Der Element-Dialog setzt den Level-Regler auf das berechnete Level und + deaktiviert ihn, sobald Kürzel und Typ im Katalog bekannt sind. +- Ohne Features ist ein Katalog-Element Base. Die gewünschte Stufe entsteht + durch Auswahl der Features, nicht durch manuelles Setzen des Levels. +- `ChSq` wird unabhängig von Features auf Level 1 gesetzt; Sprünge immer auf + Base. +- Unbekannte Freitext-Codes (`3Lz+2T`, `CCoSpV`, …) haben keine + Katalog-/Feature-Basis. Dort bleibt der Level-Regler aktiv, damit Varianten + weiterhin planbar sind. +- Der Base-Value-Hinweis und die Statusleiste folgen dem neuen Level sofort. +- Der Feature-Hinweis zeigt nur noch `Features: n · Level m`; die frühere + Mismatch-Anzeige entfällt bei automatisch abgeleiteten Elementen. + +## Auswirkungen auf Altdaten + +- Ein gespeicherter manueller Level ohne Features wird beim nächsten Öffnen + und Übernehmen auf Base normalisiert. Das ist beabsichtigt: Der Level soll + aus der dokumentierten Feature-Auswahl folgen. +- Die Validierung meldet bei alten Daten weiterhin eine Abweichung zwischen + Feature-Ergebnis und gespeichertem Level. + +## Grenzen + +1. **Features sind Eingaben, keine Messungen.** Die App kann nicht aus der + Zeichnung ableiten, ob eine schwierige Variation, ein schwieriger Ausgang + oder eine Kantenänderung tatsächlich ausgeführt wurde. +2. **Max. zwei Features pro Fuß** und Feature-Positionsregeln sind noch nicht + modelliert. +3. **Programmweite Einmal-Features** werden als Warnung geprüft, aber nicht in + die Level-Berechnung eingerechnet. +4. **Adult-Abweichungen** und GOE bleiben offen. + +## Tests + +Erweitert: `tests/run_whiteboard_tests.gd` (241 → 253 Assertions) + +- Katalog-Spin ohne Features ist Base +- vier Features ergeben Level 4, drei Level 3, zwei Level 2 +- Löschen der Features setzt den Level auf Base zurück +- Undo/Redo stellen Features und Level gemeinsam wieder her +- Level-Regler ist bei Katalog-Spin deaktiviert +- Suffix-Code und unbekannter Freitext-Code funktionieren weiterhin +- Sequenzbereich erhält Level 2 aus zwei Features + +Visuell geprüft über `tests/manual/capture_elements.gd ... features` bei +1400 × 876: `Level 2` ausgegraut, `Base Value: 2,50`, Status `CCoSp L2`. diff --git a/docs/isu-rules.md b/docs/isu-rules.md index d1f0b74..107685f 100644 --- a/docs/isu-rules.md +++ b/docs/isu-rules.md @@ -138,10 +138,13 @@ var result := rules.calculate_level( Das Segment speichert die Auswahl als `element_features` (`PackedStringArray`). Duplikate sind erlaubt, damit zwei schwierige -Variationen als zwei Features zählen. Die Daten enthalten außerdem -`once_per_program` (Feature zählt nur beim ersten Versuch im Programm) und -`max_per_element`. Die Programmprüfung und die Begrenzung „max. zwei Features -pro Fuß“ sind noch nicht umgesetzt. +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` 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 und die Begrenzung „max. zwei Features pro Fuß“ sind noch +nicht umgesetzt. ## Bedienung @@ -154,15 +157,14 @@ weiterhin ins Level-Feld normalisiert. Der Inspector zeigt unter der Level-Auswahl `Base Value: 3,50`. Unbekannte Kürzel erscheinen als „Kürzel nicht im Katalog 2025/26“. Der -Hinweis aktualisiert sich bei Änderungen an Typ, Kürzel und Level; der Tooltip -nennt Saison und Quelle. +Hinweis aktualisiert sich bei Änderungen an Typ, Kürzel und Features; der +Tooltip nennt Saison und Quelle. Darunter liegt der Button **Features (n)**. Er öffnet eine Checkbox-Liste mit den Features des Elementtyps; die Auswahl wird beim Schließen übernommen und -ist undo-fähig. Ein Hinweis zeigt die gezählten Features, das daraus -abgeleitete Level und – bei Abweichung – das manuell gewählte Level, z. B. -`Features: 2 · Level 2 · gewählt: Level 4`. Das gewählte Level bleibt -autoritativ; die Feature-Prüfung ersetzt es nicht stillschweigend. +ist undo-fähig. Der Level-Regler ist bei Katalog-Elementen read-only und folgt +der Feature-Auswahl: 0 Features → Base, 1 → Level 1 … 4 → Level 4. Der Hinweis +zeigt z. B. `Features: 2 · Level 2`. ## Prüfung diff --git a/docs/roadmap.md b/docs/roadmap.md index ed92818..6ab1071 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -119,6 +119,8 @@ Voraussetzung für Phase 1. - [x] Features und Kriterien für die Level-Vergabe – Pirouetten (14 Features) und Schrittsequenzen (4 Features), Level-Berechnung und Auswahl im Inspector; Details in `docs/isu-rules.md` +- [x] Level automatisch aus Features (Pirouetten/Sequenzen), Sprünge Base, + `ChSq` Level 1; manueller Level nur für Freitext-Codes - [x] Validierung von Elementen (Katalog, Level, Features, Level-Abgleich) mit Prüfdialog in der Statusleiste - [x] Programmweite Einmal-Features (`once_per_program`) als Warnung diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index 809dc44..54afe5b 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -617,29 +617,39 @@ func get_selected_element_features() -> PackedStringArray: return segment.element_features.duplicate() -## Replaces the feature selection of the selected element. Returns true when -## the model changed. Features are stored as codes; duplicates are kept for -## features that count more than once (e.g. difficult variations). +## 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: var segment := get_selected_segment() if segment == null or not segment.is_element(): return false var cleaned := _clean_feature_codes(features) - if segment.element_features == cleaned: + 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 + ) + if segment.element_features == cleaned and segment.element_level == new_level: return false _record_undo() segment.set_element_features(cleaned) + if derived: + segment.element_level = new_level _mark_dirty() rink_canvas.refresh() _update_status() + _update_level_control_state() update_element_feature_hint() + update_element_value_hint() return true ## Shows the feature count and the derived level in the element inspector. -## The authored level stays untouched; a mismatch is shown explicitly. func update_element_feature_hint() -> void: if element_feature_hint == null or element_features_button == null: return @@ -831,6 +841,66 @@ func _dialog_element_code() -> String: return str(metadata).strip_edges() if metadata != null else "" +## True when the level is determined by the rule set instead of the manual +## dropdown: jumps (always Base), fixed elements (ChSq) and catalog spins or +## sequences. Unknown free-text codes keep a manual level. +func _is_derived_level( + type: PathSegment.ElementType, + code: String +) -> bool: + if type == PathSegment.ElementType.JUMP: + return true + if ( + type == PathSegment.ElementType.NONE + or _element_catalog == null + or _level_rules == null + ): + return false + var definition := _element_catalog.find(code) + if definition == null or definition.element_type != type: + return false + if _level_rules.get_fixed_level(type, code) >= 0: + return true + return not _level_rules.get_features(type).is_empty() + + +func _derived_level( + type: PathSegment.ElementType, + code: String, + features: PackedStringArray +) -> int: + if type == PathSegment.ElementType.JUMP: + return 0 + if _level_rules == null: + return 0 + return _level_rules.calculate_level(type, code, features).level + + +## Features that survive a pending type change: they are cleared when the +## dialog type differs from the stored element type. +func _features_for_pending_type(type: PathSegment.ElementType) -> PackedStringArray: + var segment := get_selected_segment() + if segment == null or segment.element_type != type: + return PackedStringArray() + return segment.element_features + + +func _update_level_control_state() -> void: + if element_level_option == null: + return + var type_index := element_dialog_type_option.selected + var type: PathSegment.ElementType = PathSegment.ElementType.NONE + if type_index >= 0: + type = element_dialog_type_option.get_item_id(type_index) + var code := _dialog_element_code() + var derived := _is_derived_level(type, code) + element_level_option.disabled = derived + if derived: + _select_level_option( + _derived_level(type, code, _features_for_pending_type(type)) + ) + + ## Fills the catalog dropdown for one element type. The free-text entry stays ## available for combinations and variants that the catalog does not model. func _populate_code_options(type: PathSegment.ElementType) -> void: @@ -940,6 +1010,7 @@ func _on_element_code_option_selected(index: int) -> void: var fixed := _level_rules.get_fixed_level(type, family) if fixed >= 0: _select_level_option(fixed) + _update_level_control_state() update_element_value_hint() @@ -951,6 +1022,7 @@ func _on_element_dialog_type_selected(index: int) -> void: type, "" if type == PathSegment.ElementType.NONE else current ) + _update_level_control_state() update_element_value_hint() @@ -1008,6 +1080,11 @@ func set_selected_element( var normalized := _normalize_element_input(type, cleaned, clamped) cleaned = str(normalized["code"]) clamped = int(normalized["level"]) + if _is_derived_level(type, cleaned): + var features := segment.element_features + if type != segment.element_type: + features = PackedStringArray() + clamped = _derived_level(type, cleaned, features) var clamped_duration := -1.0 if type == PathSegment.ElementType.NONE: cleaned = "" @@ -1078,6 +1155,12 @@ func add_element_marker( str(normalized["code"]), int(normalized["level"]) ) + if _is_derived_level(type, segment.element_code): + segment.element_level = _derived_level( + type, + segment.element_code, + segment.element_features + ) segment.set_element_duration( float(ELEMENT_DEFAULT_DURATIONS.get(type, 0.0)) if duration < 0.0 @@ -1131,6 +1214,7 @@ func _setup_element_controls() -> void: func _on_element_code_text_changed(_text: String) -> void: + _update_level_control_state() update_element_value_hint() @@ -1167,6 +1251,7 @@ func _open_element_dialog() -> void: level_index = 0 element_level_option.select(level_index) _select_code_in_option(segment.element_type, segment.element_code) + _update_level_control_state() var is_marker := segment.is_element_marker() element_duration_spin.set_value_no_signal(segment.element_duration_seconds) diff --git a/rinkplanner/tests/run_whiteboard_tests.gd b/rinkplanner/tests/run_whiteboard_tests.gd index f64532e..0d679da 100644 --- a/rinkplanner/tests/run_whiteboard_tests.gd +++ b/rinkplanner/tests/run_whiteboard_tests.gd @@ -720,12 +720,12 @@ func _run() -> void: "element code and level can be edited" ) _check( - spin.element_code == "CCoSp" and spin.element_level == 4, - "a canonical level suffix is moved into the level field" + spin.element_code == "CCoSp" and spin.element_level == 0, + "a canonical suffix is normalized; without features the level is Base" ) _check( - spin.get_element_caption() == "CCoSp L4", - "marker caption includes code and level" + spin.get_element_caption() == "CCoSp", + "marker caption omits the derived Base level" ) _check_approx( spin.element_duration_seconds, @@ -745,9 +745,28 @@ func _run() -> void: _check(controller.redo(), "element edit can be redone") spin = controller.get_active_section().get_segment_by_id(spin.segment_id) _check( - spin != null and spin.get_element_caption() == "CCoSp L4", + spin != null and spin.element_code == "CCoSp", "redo restores the element data" ) + controller.select_segment(spin.segment_id) + _check( + controller.set_selected_element_features( + PackedStringArray( + [ + "difficult_variation", + "difficult_variation", + "difficult_exit", + "change_of_edge", + ] + ) + ), + "features derive the level" + ) + _check(spin.element_level == 4, "four features derive Level 4") + _check( + spin.get_element_caption() == "CCoSp L4", + "marker caption includes the derived level" + ) # Element inspector dialog. controller.select_segment(spin.segment_id) @@ -775,6 +794,10 @@ func _run() -> void: ) == 4, "element dialog is prefilled with the normalized level" ) + _check( + controller.element_level_option.disabled, + "the level is read-only for a catalog spin" + ) var catalog := controller.get_element_catalog() _check(catalog != null and catalog.season == "2025/26", "controller loads the ISU catalog") _check( @@ -783,13 +806,22 @@ func _run() -> void: ) _select_dialog_code(controller, "CCoSp") - controller.element_level_option.select( - controller.element_level_option.get_item_index(2) + _check( + controller.set_selected_element_features( + PackedStringArray(["difficult_variation", "difficult_exit"]) + ), + "features update the derived level" + ) + _check( + controller.element_level_option.get_item_id( + controller.element_level_option.selected + ) == 2, + "the level dropdown follows two features" ) controller.update_element_value_hint() _check( controller.element_value_label.text.contains("2,50"), - "base value follows a family code and level 2" + "base value follows the derived level 2" ) _set_dialog_free_text(controller, "CCoSp4") @@ -799,7 +831,7 @@ func _run() -> void: ) _check( controller.element_value_label.text.contains("3,50"), - "a canonical suffix wins over the level control" + "a canonical suffix wins over the derived level" ) _set_dialog_free_text(controller, "3X") @@ -809,21 +841,14 @@ func _run() -> void: ) # Level features and the derived level. - _check( - controller.set_selected_element_features( - PackedStringArray(["difficult_variation", "difficult_exit"]) - ), - "features can be assigned to an element" - ) _check( controller.get_selected_element_features().size() == 2, "features are stored on the selected segment" ) _check( controller.element_feature_hint.text.contains("Features: 2") - and controller.element_feature_hint.text.contains("Level 2") - and controller.element_feature_hint.text.contains("gewählt: Level 4"), - "feature hint shows the derived level and the mismatch" + and controller.element_feature_hint.text.contains("Level 2"), + "feature hint shows the derived level" ) _check( not controller.element_features_button.disabled, @@ -860,9 +885,11 @@ func _run() -> void: controller.get_selected_element_features().size() == 3, "a second difficult variation can be added" ) + _check(spin.element_level == 3, "three features derive Level 3") _check( - controller.element_feature_hint.text.contains("Features: 3"), - "feature hint follows the selection" + controller.element_feature_hint.text.contains("Features: 3") + and controller.element_feature_hint.text.contains("Level 3"), + "feature hint follows the selection and level" ) _check(controller.undo(), "feature selection can be undone") spin = controller.get_active_section().get_segment_by_id(spin.segment_id) @@ -872,6 +899,7 @@ func _run() -> void: controller.get_selected_element_features().size() == 2, "undo restores the previous feature selection" ) + _check(spin.element_level == 2, "undo restores the derived level") _check(controller.redo(), "feature selection can be redone") spin = controller.get_active_section().get_segment_by_id(spin.segment_id) _check(spin != null, "the spin survives redo") @@ -880,6 +908,7 @@ func _run() -> void: controller.get_selected_element_features().size() == 3, "redo restores the feature selection" ) + _check(spin.element_level == 3, "redo restores the derived level") _check( controller.set_selected_element_features(PackedStringArray()), "features can be cleared" @@ -888,16 +917,21 @@ func _run() -> void: controller.get_selected_element_features().is_empty(), "clearing removes all features" ) + _check(spin.element_level == 0, "clearing features resets the level to Base") - _select_dialog_code(controller, "CCoSp") - controller.element_level_option.select( - controller.element_level_option.get_item_index(2) + _check( + controller.set_selected_element_features( + PackedStringArray(["difficult_variation", "difficult_exit"]) + ), + "features restore Level 2" ) + _check(spin.element_level == 2, "the restored level is Level 2") + _select_dialog_code(controller, "CCoSp") controller.element_duration_spin.value = 6.5 controller.element_dialog.confirmed.emit() _check( controller.get_selected_element_caption() == "CCoSp L2", - "element dialog applies code and level" + "element dialog applies the derived level" ) _check_approx( controller.get_selected_segment().element_duration_seconds, @@ -977,9 +1011,15 @@ func _run() -> void: ), "a drawn segment can carry a sequence element" ) + _check( + controller.set_selected_element_features( + PackedStringArray(["variety_of_turns", "both_rotations"]) + ), + "a sequence range can carry level features" + ) _check( controller.get_selected_element_caption() == "StSq L2", - "sequence range caption combines code and level" + "sequence range caption combines code and derived level" ) _check( controller.set_selected_element(PathSegment.ElementType.NONE, "", 0),