feat: Features pro Fuß und Variationen je Kategorie begrenzen
Schritt 7 der Mehrsaison-Reihe: Die Level-Features folgen jetzt den drei Zählregeln aus ISU 2788. - "In any spin with change of foot the maximum number of features attained on one foot is two (2)." Level-Berechnung deckelt pro Fuß; der Validator meldet zu viele Features auf einem Fuß und fehlende Fußangaben. - "In any spin only two (2) difficult variations are counted." Die Gruppe difficult_variation hat einen Deckel in den Daten (types.spin.groups). - "Any category of difficult spin variation in a basic position counts only once per program." Die Variation ist in fünf Kategorien aufgeteilt (Sitz, Camel, Layback, Upright, Sonstige); damit greift einmal-pro-Programm ohne Sonderlogik. Daten: `per_foot` je Feature, `max_features_per_foot` je Elementtyp, `change_of_foot` im Katalog (sechs Pirouetten mit Fußwechsel; CSp ist die Camel-Pirouette, nicht Change foot). Schema 9 speichert den Fuß als `element_feature_feet` (Code → L/R). Oberfläche: Die Fußauswahl erscheint nur, wenn sie das Ergebnis ändern kann – bei einer Fußwechsel-Pirouette mit mehr als zwei fußbezogenen Features. Angaben zu Level und Ausführung bleiben Selbsteinschätzung; das entscheidet weiterhin das technische Panel.
This commit is contained in:
parent
1a51debf6c
commit
31d4e70ba1
24 changed files with 944 additions and 170 deletions
|
|
@ -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.
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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."
|
||||
|
|
|
|||
|
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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 = ""
|
||||
|
|
|
|||
|
|
@ -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": [
|
||||
{
|
||||
|
|
|
|||
|
|
@ -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",
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
]
|
||||
},
|
||||
|
|
|
|||
|
|
@ -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
|
||||
}
|
||||
]
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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"]
|
||||
|
|
|
|||
|
|
@ -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] = {}
|
||||
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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])
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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
|
||||
)
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -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":
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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),
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue