feat: add step-sequence groups, freehand editing and element PDF

- group contiguous path segments into one sequence element with shared group IDs
- resolve elements centrally and score/adult-count groups once
- add freehand tool with point editing, smoothing and RDP reduction
- render one PDF table row and badge per element instead of per segment
- turn playback start/pause/reset into icon buttons
- add multi-select grouping and extend tests/documentation
This commit is contained in:
torsten 2026-11-10 15:50:03 +01:00
parent e9d520459e
commit 55e7b163b5
33 changed files with 4623 additions and 345 deletions

View file

@ -58,8 +58,9 @@ Implementiert in `rinkplanner/src/core/model/`:
| Klasse | Verantwortung |
| :--- | :--- |
| `Routine` | Wurzelaggregat, Validierung, Gesamtdauer/-länge, Section-Lookup, Adult-Kategorie |
| `RoutineSection` | chronologischer Block, Ghosting-Einheit, Segmentliste |
| `PathSegment` | Pfad mit Richtung, Kante, Dauer, Element-Marker, Sprungkombination und Label |
| `RoutineSection` | chronologischer Block, Ghosting-Einheit, Segmentliste, Elementauflösung |
| `PathSegment` | Pfad mit Richtung, Kante, Dauer, Elementdaten (Lead), Gruppen-ID und Label |
| `ResolvedElement` | Lese-Sicht auf ein Element: Lead, Mitgliedssegmente, Dauer, Caption, Gruppenanker |
| `RinkDimensions` | Maße, Koordinaten, Punkte-/Kurvenprüfung |
| `RoutineFile` | JSON-Serialisierung, atomare Saves, Legacy-`.tres`-Import |
@ -255,10 +256,23 @@ Fahrtrichtung.
(Segment anlegen, Kante umschalten, Section wechseln, Playback steuern).
- **Zeichenwerkzeuge:** `WhiteboardController` hält eine Draft-Routine mit
einer Section. Die Toolbar bietet Auswählen, Linie, Bogen links, Bogen
rechts und Element; Richtung (vorwärts/rückwärts) und Kante (innen/außen)
gelten für das nächste Segment. Neue Segmente starten mit dem gewählten
Timing-Profil (Default Adult Gold, 4,3 m/s); Züge über die Bande werden per
`clamp_point()` auf die Eisfläche begrenzt.
rechts, Freeline und Element; Richtung (vorwärts/rückwärts) und Kante
(innen/außen) gelten für das nächste Segment. Neue Segmente starten mit dem
gewählten Timing-Profil (Default Adult Gold, 4,3 m/s); Züge über die Bande
werden per `clamp_point()` auf die Eisfläche begrenzt.
- **Freeline:** Der Freeline-Modus sammelt die gezogene Bewegung als
mehrpunktige `Curve2D` (ca. 2,5 px Punktabstand, max. 4.000 Punkte pro
Segment). Die Vorlage `Template.FREEHAND` bleibt erhalten, damit
Start-/Endgriffe nur den jeweiligen Endpunkt verschieben und die Kurve
nicht zu einer Linie zusammenfällt. Im Auswahlmodus zeigt der Canvas bis zu
64 gleichmäßig verteilte Zwischenpunkte als kleine Griffe; ein Drag bewegt
den jeweiligen Kurvenpunkt (Detail-Index im Handle-Signal), alle anderen
Punkte bleiben unverändert. „Glätten“ in der Timing-Leiste führt zwei
Laplacian-Durchgänge auf den Innenpunkten aus (Endpunkte fest, undo-fähig,
mehrfach anwendbar). Eine iterative RDP-Reduktion entfernt beim Abschluss
(ca. 1 px Toleranz, zoomabhängig) und über „Vereinfachen“ überflüssige
Zwischenpunkte; Endpunkte und Form bleiben erhalten. Länge, Dauer, Playback,
3D, SVG und PDF nutzen dieselbe Kurve wie die anderen Pfadsegmente.
- **Bogen-Vorlage:** `ArcGeometry` erzeugt einen Kreisbogen mit 40 % der
Sehnenlänge als Pfeilhöhe und liefert eine gesampelte `Curve2D`-Polyline.
Liegt der Bogen außerhalb des Rinks, wird die Pfeilhöhe schrittweise
@ -277,15 +291,48 @@ Fahrtrichtung.
nicht interaktiv. Die Bogenparameter werden als `template`,
`arc_depth_ratio` und `arc_bulge_left` am `PathSegment` gespeichert, damit
die Kurve nach dem Editieren neu aufgebaut werden kann.
- **Element-Marker:** Das Werkzeug „Element“ setzt per Tipp einen Punktmarker
(Ein-Punkt-Kurve, Dauer 0) des in der Timing-Leiste gewählten Typs
(Sprung/Pirouette/Sequenz). Der Marker wird direkt ausgewählt; der Button
- **Element-Marker:** Die Werkzeuge „Sprung“ und „Pirouette“ setzen per Tipp
einen Punktmarker (Ein-Punkt-Kurve, Dauer 0) des jeweiligen Typs; der Typ ist
damit schon vor dem Platzieren festgelegt. Die Einfügeposition folgt der
gezeichneten Laufspur: Der Marker landet an der Stelle zwischen den
Segmenten, deren Pfad dem Tipp am nächsten liegt – auch am Anfang oder in
der Mitte eines Abschnitts. Wiederholte Tipps an derselben Stelle behalten
ihre Reihenfolge. Der Marker wird direkt ausgewählt; der Button
„Element“ öffnet den Inspector für Typ, Kürzel und Level. Im
Auswahlmodus lässt sich der Marker über seinen Griff verschieben. Sequenz-
Bereiche entstehen, indem ein gezeichnetes Segment über den Inspector
getaggt wird. Punktmarker haben eine **Standzeit** (`element_duration_seconds`)
mit Typ-Defaults (Sprung 0,7 s, Pirouette 8 s, Sequenz 0 s), die im
Inspector übersteuert wird und in die Timeline eingeht. Das Kürzel wird
Auswahlmodus lässt sich der Marker über seinen Griff verschieben.
Das **Sequenz-Symbol** startet den Sequenz-Zeichenmodus: Die erste
gezeichnete Strecke wird Lead eines Bereichs, weitere Strecken treten über
dieselbe `element_group_id` bei. Die Gruppe zählt in Prüfung, Basiswert,
Adult-Regeln, Timeline und Export als **ein** Element. Ein beliebiges
Mitglied lässt sich auswählen; der Inspector bearbeitet immer das Lead-
Segment. Beim Löschen des Leads übernimmt das nächste Mitglied die
Elementdaten. `RoutineSection.get_elements()` löst Einzelelemente und
Gruppen zu `ResolvedElement`-Sichten auf; alle Wertungs- und Anzeigepfade
iterieren darüber statt über die Rohsegmente. Die **Mehrfachauswahl**
(Knopf im Abschnittsbereich oder Shift/Cmd/Ctrl-Klick) erlaubt das
nachträgliche Gruppieren zusammenhängender Segmente über
„Sequenz gruppieren“; der Controller prüft Lücken, Marker und bestehende
Elemente, bevor er den Undo-fähigen Gruppenschritt ausführt. Punktmarker haben eine
**Standzeit** (`element_duration_seconds`)
mit Typ-Defaults (Sprung 0,7 s, Pirouette 4 s, Sequenz 0 s), die im
Inspector übersteuert wird und in die Timeline eingeht. Pirouetten tragen
zusätzlich eine **Umdrehungszahl** (`element_revolutions`, Default aus
4 s × 2,5 U/s = 10) und eine **Drehrichtung**
(`element_rotation_direction`, Default linksherum, weil ~85–90 % der Läufer
gegen den Uhrzeigersinn drehen); der Playback dreht mit Umdrehungen /
Standzeit in dieser Richtung. Sprünge zeigen im Canvas einen **Sprungvektor**
entlang der Ankunftsrichtung mit der Distanz im Kürzel-Label
(`3Lz · 3,0 m`); ohne manuelle Änderung wird die Weite aus dem Kürzel
abgeleitet (1 m pro Luftumdrehung, Axel +0,5). Die **Pfeilspitze ist ein
Griff**: Ziehen speichert Richtung und Weite in `element_jump_vector` und
überschreibt damit die Heuristik. Beim Abspielen wächst der Marker in der
Luft
(Sinuskurve über die Standzeit) und dreht sich mit der Sprungdrehung
(3Lz = 3 Umdrehungen), ebenfalls in der eingestellten Richtung. Beim
Abspielen wandert der Marker entlang des Sprungvektors vom Absprung zum
Landepunkt; folgt die gezeichnete Spur nicht dort weiter, springt der Marker
wie bei anderen nicht verbundenen Segmenten zum nächsten Startpunkt. Das
Kürzel wird
über eine Auswahlbox aus dem Katalog gewählt (mit Freitext-Fallback für
Kombinationen und Varianten). Der Inspector zeigt
außerdem den **Base Value** des eingegebenen Kürzels und Levels aus dem
@ -336,12 +383,18 @@ Fahrtrichtung.
kontinuierlich per Bogenlängen-Sampling (`sample_baked()`). Die Blickrichtung
folgt der Kurventangente; bei Rückwärts-Segmenten wird sie um 180° gedreht,
sodass die Bewegung entlang des Pfades und die Körperrichtung getrennt
sichtbar sind. Punktmarker halten die Ankunftsrichtung, Pirouetten drehen
den Marker während der Standzeit mit 1,5 Umdrehungen pro Sekunde. Während
sichtbar sind. Punktmarker halten die Ankunftsrichtung. Pirouetten drehen
den Marker während der Standzeit mit der geplanten Umdrehungszahl geteilt
durch die Standzeit (Fallback für alte Dateien: 2,5 U/s) in der
eingestellten Drehrichtung. Sprünge drehen sich mit ihrer Luftumdrehung
(aus dem Kürzel, z. B. 3Lz = 3), wandern dabei vom Absprung entlang des
Sprungvektors zum Landepunkt und der Marker wächst zur Sprungmitte hin
auf das 1,85-Fache, um die Luftphase zu zeigen. Während
des Playbacks wird die aktuelle Section hervorgehoben,
ohne die Bearbeitungs-Section zu wechseln. Ein **▶** markiert sie in der
Abschnittsliste; ihr Name erscheint kurz oben auf der Eisfläche und blendet
sich innerhalb von zwei Sekunden aus. Steuerung: Play/Pause, Reset,
sich innerhalb von zwei Sekunden aus. Steuerung: Icon-Knöpfe für
Start/Pause und Reset (Rekorder-Symbole, Tooltips nennen die Aktion),
Timeline-Scrubbing und Geschwindigkeit 0,25×–2,0×. Ein optionales
Musikstück (MP3/OGG/WAV) liegt neben der Kür-JSON in `user://routines/`
und läuft über einen `AudioStreamPlayer` auf derselben Zeitbasis: Start,
@ -401,10 +454,17 @@ wird trotzdem in Gerätepixeln gerendert:
### Responsive Leiste
- Ab 1280 px Breite: volle Beschriftungen („Rinkplanner“, „Werkzeug“,
- Die Werkzeuge liegen als Icon-Leiste in der Kopfzeile: Mauszeiger für
„Auswählen“, Linie, linker und rechter Bogen sowie drei Element-Icons
(springendes Strichmännchen mit Pfeil = Sprung, hockendes mit Kreispfeil =
Pirouette, gehendes = Sequenz). Beim Start ist „Auswählen“ aktiv. Das aktive
Werkzeug wird erhellt (weißes Icon) und mit einem weißen Rahmen markiert;
Tooltips nennen den Namen.
- Ab 1390 px Breite: volle Beschriftungen („Rinkplanner“, „Vorwärts“,
„Rückgängig“, „Wiederholen“, „Kalibrieren“).
- Unter 1280 px: kompakte Beschriftungen („Undo“, „Redo“, „Kalib.“), Titel und
Werkzeug-Label entfallen, das Sections-Panel wird 260 statt 300 px breit.
- Unter 1390 px: kompakte Beschriftungen („Undo“, „Redo“, „Vor“, „Rück“,
„Fit“, „Kalib.“), der Titel entfällt, die Werkzeug-Icons werden 44 statt
48 px breit, das Sections-Panel 260 statt 300 px.
- Die Timing-Leiste ist ein `HFlowContainer` und bricht bei Bedarf um, statt
seitlich abgeschnitten zu werden.
- Geprüfte Landschaftsbreiten: 1024 px (kleine Tablets) und 1400 px
@ -440,18 +500,22 @@ ggf. eines nach `touchend` (300-ms-Guard).
- **PDF** erzeugt `RoutinePdfExporter` direkt als Vektordokument über einen
kleinen eigenen PDF-Writer (Helvetica/WinAnsi, keine externe Bibliothek):
eine Übersichtsseite mit allen Laufwegen und der Abschnittstabelle, danach
eine Seite pro Abschnitt mit nummerierten Laufwegen sowie Start-/Endzeit,
Dauer und Element bzw. Label. Lange Abschnitte laufen auf
Fortsetzungsseiten weiter. Die Kurven werden als PDF-Bézierkurven aus den
eine Seite pro Abschnitt. Die Badges nummerieren die **Elemente** in
Reihenfolge; die Tabelle hat eine Zeile pro Element mit Start-/Endzeit,
Dauer, Element/Label und bei Sequenzbereichen der Teilstrecken-Anzahl.
Reine Laufwege ohne Element werden gezeichnet, aber nicht tabelliert.
Lange Abschnitte laufen auf Fortsetzungsseiten weiter. Die Kurven werden als PDF-Bézierkurven aus den
`Curve2D`-Handles geschrieben. Nach jedem Export zeigt ein Abschlussdialog
den absoluten Pfad und bietet **Öffnen**, **Ordner anzeigen** und
**Pfad kopieren** über `OS.shell_open` / `OS.shell_show_in_file_manager`;
optional startet das Ergebnis direkt im Standardprogramm.
- **Persistenz** erfolgt lokal als JSON unter `user://routines/`
(`RoutineFile`, Format `rinkplanner.routine`). Die Datei enthält
`schema_version` (aktuell 4); neuere Schemata werden abgelehnt,
`schema_version` (aktuell 6); neuere Schemata werden abgelehnt,
ältere Dateien beim Laden migriert (Schema 1: Dauer→Tempo, Schema 2→3:
additives Feld `music_file`, Schema 3→4: additive Timeline-Labels).
additives Feld `music_file`, Schema 3→4: additive Timeline-Labels,
Schema 4→5: additives Feld `element_group_id` für Sequenzbereiche,
Schema 5→6: Vorlagenwert `freehand` für Freeline-Segmente).
Die Elementfelder kamen additiv mit
Defaults hinzu. Legacy-`.tres`-Dateien
bleiben lesbar: Vor `ResourceLoader.load` prüft `RoutineFile` eine

View file

@ -0,0 +1,61 @@
# Findings – Freeline-Werkzeug (2026-11-10)
## Ergebnis
Die Werkzeugleiste hat ein neues **Freeline**-Werkzeug. Es zeichnet den
Laufweg frei mit Maus oder Finger und speichert ihn als mehrpunktige Kurve.
Das Icon ist eine gekräuselte Linie mit Stift (`assets/icons/tools/freeline.svg`).
| Ziel | Ergebnis |
| :--- | :--- |
| Werkzeug | `Tool.FREELINE` zwischen den Bögen und den Element-Werkzeugen |
| Modell | `PathSegment.Template.FREEHAND` + mehrpunktige `Curve2D` |
| Sampling | ca. 2,5 px Punktabstand, max. 4.000 Punkte pro Segment |
| Bearbeitung | Start-/Endgriff verschieben den jeweiligen Endpunkt, ohne die Kurve zu kollabieren |
| Wiedergabe | Playback, 3D, SVG und PDF nutzen dieselbe Kurve wie Linie/Bogen |
| Persistenz | Schema 6, Vorlagenwert `freehand` |
| Tests | `./tools/test.sh` grün |
## Modell und Zeichnen
- Beim Start legt der Controller ein Segment mit einem Startpunkt an.
- Jede Bewegung wird in Rink-Koordinaten geklemmt und nur übernommen, wenn sie
weit genug vom letzten Punkt entfernt ist. Der Abstand orientiert sich mit
`FREELINE_POINT_STEP_PX` an der aktuellen Zoomstufe.
- Bei `draw_finished` wird der letzte Punkt ergänzt und die Dauer aus Länge und
Timing-Profil aktualisiert. Zu kurze Striche werden wie bei Linie/Bogen
verworfen.
- Start- und Endgriff bearbeiten bei `Template.FREEHAND` den ersten bzw.
letzten Kurvenpunkt direkt. Zusätzlich zeigt der Canvas bis zu 64
gleichmäßig verteilte Zwischenpunkte als kleine Griffe. Ein Drag bewegt den
jeweiligen Kurvenpunkt über einen Detail-Index im Handle-Signal; alle
anderen Punkte bleiben erhalten. Es gibt keinen Bogen-Griff.
- **Glätten:** Der Timing-Button führt zwei Laplacian-Durchgänge auf den
Innenpunkten aus. Start/Ende bleiben fest, die Punktanzahl bleibt gleich,
Länge/Dauer werden neu berechnet und jeder Druck ist undo-fähig.
- **Punktreduktion:** Eine iterative RDP-Reduktion läuft beim Abschluss einer
Freeline automatisch (ca. 1 px Toleranz, in Meter umgerechnet) und über den
Button „Vereinfachen“ für bestehende Segmente. Endpunkte bleiben erhalten;
die Aktion ist undo-fähig.
- Freeline-Segmente sind normale Pfadsegmente: Richtung, Kante, Label, Timing,
Löschen, Undo/Redo, Multi-Auswahl und Sequenzgruppierung funktionieren wie
bei Linie/Bogen.
## Oberfläche
- Neuer Toolbar-Button mit Tooltip „Freeline“. Im kompakten 1024-px-Layout
wurden die übrigen Topbar-Mindestbreiten leicht reduziert, damit die Leiste
weiterhin ohne Umbruch passt.
- Statusleiste zeigt „Freeline“ als Auswahlart und den Zeichenhinweis.
- Das Icon verwendet denselben weißen Strich wie die vorhandenen Werkzeuge.
## Offene Punkte
1. **Toleranz:** Die RDP-Reduktion nutzt einen konservativen Startwert von
etwa einem Bildschirmpixel. Eine einstellbare Stärke (z. B. für besonders
detailreiche Zeichnungen) ist noch offen.
2. **Sehr feine Kurven:** Bei mehr als 64 Punkten zeigt der Editor nur eine
gleichmäßige Auswahl als Griffe; nicht sichtbare Zwischenpunkte lassen
sich nicht direkt greifen.
3. **Druck/Export:** SVG/PDF übernehmen die Kurve; eine gesonderte
Freeline-Legende gibt es nicht.

View file

@ -0,0 +1,62 @@
# Findings – Step Sequences als Elementgruppe (2026-11-10)
## Ergebnis
Schrittsequenzen können jetzt als **ein** Element über mehrere gezeichnete
Teilstrecken laufen. Das ist Option A aus dem Modell-Brainstorm: Die
Elementdaten bleiben am Lead-Segment, die Mitglieder verweisen über eine
gemeinsame `element_group_id` darauf.
| Ziel | Ergebnis |
| :--- | :--- |
| Modell | `PathSegment.element_group_id`; Lead trägt Typ, Kürzel, Level, Features |
| Auflösung | `RoutineSection.get_elements()` liefert `ResolvedElement`-Sichten |
| Wertung | Validator, Adult-Regeln und Basiswert zählen eine Gruppe einmal |
| Darstellung | ein Label pro Gruppe am Gruppenmittelpunkt (Canvas und SVG) |
| PDF | eine Tabellenzeile und ein Rink-Badge pro Element, nicht pro Segment |
| Bedienung | Sequenz-Zeichenmodus und nachträgliches Gruppieren per Mehrfachauswahl |
| Persistenz | Schema 5, additives `element_group_id` |
| Tests | `./tools/test.sh` grün |
## Modell
- `element_group_id` ist auf allen Mitgliedern gleich. Genau ein Segment ist
Lead (`element_type != NONE`); die übrigen sind normale Pfadsegmente ohne
Elementdaten.
- Gruppen sind zusammenhängend und liegen in einer Section. Mehrere Leads,
Lücken, Null-Längen-Mitglieder und Nicht-Sequenz-Typen werden abgelehnt.
- `ResolvedElement` kapselt Lead, Mitglieder, Dauer, Caption, Länge und den
Mittelpunkt der Gruppe. Die Sicht ist ephemär; ein erneutes Auflösen liefert
ein neues Objekt mit derselben `element_id`.
- Alte Dateien ohne Gruppen-ID bleiben gültig: Jedes getaggte Segment ist ein
Einzelelement. Schema 4 → 5 ist rein additiv.
## Bedienung
- Das Sequenz-Symbol startet den Zeichenmodus. Linie/Bogen/Freeline zeichnen
die Teilstrecken; die erste wird Lead. Erneutes Drücken, Esc oder ein
anderes Werkzeug beendet den Bereich.
- Eine bestehende Sequenz am Abschnittsende lässt sich fortsetzen: Mitglied
auswählen, Sequenz-Symbol drücken, weiterzeichnen.
- Ein beliebiges Mitglied öffnet im Element-Dialog immer die Gruppe.
- Lead löschen: Das nächste Mitglied übernimmt die Elementdaten.
- „Kein Element“ löst die Gruppe auf; die Pfadsegmente bleiben erhalten.
- Neue Bereiche starten mit `StSq` und Level Base.
- **Mehrfachauswahl:** Der Knopf im Abschnittsbereich schaltet auf
addierendes Antippen; auf dem Desktop geht auch Shift/Cmd/Ctrl-Klick.
„Sequenz gruppieren (N)“ fasst eine zusammenhängende Auswahl in einem
Undo-Schritt zusammen. Lücken, Marker und bestehende Elemente blockieren
die Aktion.
## Offene Punkte
1. **Teilen/Zusammenführen:** Eine Gruppe kann derzeit nur über Löschen oder
„Kein Element“ verändert werden; ein explizites Teilen fehlt.
2. **Gruppen-Hervorhebung:** Der Canvas markiert beim Auswählen nur das
gewählte Segment, nicht die gesamte Gruppe.
3. **Einzelne Sequenz-Tags zusammenführen:** Bereits separat getaggte
Sequenzen müssen vor dem Gruppieren über „Kein Element“ gelöst werden;
ein automatisches Zusammenführen mit Metadaten-Konfliktlösung fehlt.
4. **Punktmarker:** Sprung/Pirouette bleiben Einzelelemente mit einem
Ankersegment. Eine vollständige `RoutineElement`-Ablage (Option B) ist
weiterhin der langfristige Umbau.

View file

@ -9,12 +9,89 @@ App über den Button **?** in der Statusleiste erreichbar.
1. Kür anlegen oder öffnen.
2. In der Statusleiste die **Adult-Kategorie** wählen (Gold, Silver, Bronze,
Masters, Masters Elite).
3. Elemente aufs Eis setzen: Linie, Bogen oder Element-Marker.
3. Elemente aufs Eis setzen: Linie, Bogen, Freeline oder Element-Marker.
4. Im Element-Dialog **Kürzel**, **Features** und ggf. **Standzeit** festlegen.
5. **Prüfen** öffnen: Prüfliste, Befunde und Punktschätzung ansehen.
6. Optional **3D** in der oberen Leiste öffnen, um die Kür als Vorschau
abzuspielen.
## Laufwege zeichnen
- **Linie** und die beiden **Bogen**-Werkzeuge erzeugen eine gerade Strecke
bzw. einen Kreisbogen zwischen Start- und Endpunkt.
- **Freeline** zeichnet den Weg frei mit der Maus oder dem Finger. Die
Bewegung wird als mehrpunktige Kurve gespeichert; sie bleibt damit auch in
Playback, 3D-Vorschau sowie SVG-/PDF-Export eine echte Freiform.
- Im Auswahlmodus zeigt eine Freeline neben den großen Start-/Endgriffen
kleine weiße Punkte entlang der Kurve. Jeder dieser Punkte lässt sich
ziehen und formt die Freeline nachträglich um; die übrigen Punkte bleiben
erhalten. Bei sehr langen Freelines werden bis zu 64 Punkte als Griffe
angeboten.
- **Glätten** in der Timing-Leiste zeichnet die ausgewählte Freeline weicher.
Ein Druck glättet in zwei Durchgängen; Start- und Endpunkt bleiben fest.
Die Aktion ist undo-fähig und kann mehrfach angewendet werden.
- **Vereinfachen** entfernt überflüssige Zwischenpunkte (Ramer-Douglas-
Peucker) und lässt die Form dabei erhalten. Das passiert beim Abschluss
einer Freeline automatisch mit einer Toleranz von etwa einem Bildschirm-
pixel; für bestehende Freelines gibt es den gleichnamigen Button. Auch
diese Aktion ist undo-fähig.
- Richtung (vorwärts/rückwärts) und Kante (innen/außen) gelten wie bei den
anderen Werkzeugen für das nächste Segment und lassen sich nachträglich
ändern. Dauer und Tempo stehen in der Timing-Leiste.
## Elemente platzieren
Die Werkzeuge **Sprung**, **Pirouette** und **Sequenz** setzen per Tipp einen
Element-Marker. Wo der Marker in der Kür erscheint, entscheidet die gezeichnete
Laufspur:
- Ein Tipp am **Anfang** der Spur setzt das Element an den Abschnittsanfang.
- Ein Tipp **zwischen zwei Segmenten** fügt das Element an dieser Stelle ein.
- Ein Tipp **hinter dem letzten Segment** hängt das Element hinten an.
Mehrere Marker an derselben Stelle behalten die Reihenfolge, in der sie gesetzt
wurden. Der Tipp bestimmt nur die zeitliche Position; der Marker selbst bleibt
an der getippten Stelle auf dem Eis und lässt sich im Auswahlmodus verschieben.
### Schrittsequenzen als Bereich
Eine Schrittsequenz besteht oft aus mehreren Teilstrecken, zählt aber als
**ein** Element mit einem Kürzel, einem Level und einem Basiswert.
- Das **Sequenz-Symbol** in der Werkzeugleiste startet den Sequenz-Zeichenmodus.
- Mit **Linie**, **Bogen** oder **Freeline** werden die Teilstrecken
gezeichnet. Die erste Strecke wird das Lead-Segment, alle weiteren treten
derselben Sequenz bei.
- Erneut **Sequenz** drücken oder ein anderes Werkzeug als Linie/Bogen/
Freeline wählen beendet den Bereich. Neue Strecken danach gehören nicht
mehr dazu.
- Eine bestehende Sequenz lässt sich fortsetzen, solange sie am Abschnittsende
liegt: ein Mitglied auswählen, das Sequenz-Symbol drücken und
weiterzeichnen.
- Klickt man ein beliebiges Mitglied an, öffnet der **Element**-Dialog die
ganze Sequenz. Kürzel, Level und Features gelten einmal für alle Teilstrecken.
- Wird das Lead-Segment gelöscht, übernimmt das nächste Mitglied automatisch
die Elementdaten. **Kein Element** im Dialog löst die Gruppe auf; die
gezeichneten Teilstrecken bleiben erhalten.
- Neue Sequenzbereiche starten mit dem Kürzel `StSq` und Level Base; beides
lässt sich im Element-Dialog ändern.
### Nachträglich gruppieren
Bestehende Teilstrecken lassen sich ohne Neuzeichnen zu einer Sequenz
zusammenfassen:
1. **Mehrfachauswahl** im Abschnittsbereich aktivieren.
2. Die gewünschten Segmente antippen. Erneutes Antippen entfernt ein Segment
wieder aus der Auswahl. Auf dem Desktop funktioniert auch
**Shift/Cmd/Ctrl + Klick** ohne aktivierte Mehrfachauswahl.
3. **Sequenz gruppieren (N)** drücken.
Die Auswahl muss aus mindestens zwei **zusammenhängenden** Pfadsegmenten
bestehen und darf keine bestehenden Elemente oder Sprung-/Pirouettenmarker
enthalten. Nach dem Gruppieren wird das Lead-Segment ausgewählt und die
Mehrfachauswahl beendet. Esc bricht die Mehrfachauswahl ab.
## 3D-Vorschau
Der Button **3D** in der oberen Leiste wechselt in eine schreibgeschützte
@ -69,7 +146,8 @@ Ein Musikstück gehört optional zur Kür. **Musik…** in der Playback-Leiste
öffnet die Dateiauswahl für **MP3** (auch OGG/WAV). Die Datei wird in den
Kür-Ordner kopiert und in der Kür-JSON als Dateiname vermerkt.
- **Start/Pause/Reset** steuern Bild und Musik gemeinsam.
- Die Symbolknöpfe **Start/Pause** (▶/⏸) und **Reset** (⏮) steuern Bild und
Musik gemeinsam; die Tooltips nennen die jeweilige Aktion.
- **Timeline-Scrubbing** setzt auch die Musik an die entsprechende Stelle.
- **Geschwindigkeit** wirkt auf beide: bei 0,5× läuft die Musik langsamer
(und tiefer), bei 2× schneller.
@ -100,8 +178,8 @@ Kür-Ordner kopiert und in der Kür-JSON als Dateiname vermerkt.
Wird in der Abschnittsliste ein anderer Abschnitt gewählt, springen die
Abspielfigur und die Playback-Timeline an den **Anfang dieses Abschnitts**.
Eine laufende Wiedergabe wird dabei angehalten; mit **Start** läuft sie ab
dieser Stelle weiter. Die Position berücksichtigt alle davor liegenden
Eine laufende Wiedergabe wird dabei angehalten; mit dem **Start-Symbol**
läuft sie ab dieser Stelle weiter. Die Position berücksichtigt alle davor liegenden
Abschnitte inklusive Element-Standzeiten.
Während der Wiedergabe markiert ein **▶** den aktuellen Abschnitt in der
@ -115,9 +193,11 @@ und blendet sich innerhalb von zwei Sekunden weich aus.
- **SVG (Vektor):** gesamte Kür oder aktiver Abschnitt als druckbares Blatt.
- **PNG (hochauflösend):** 2560 × 1600 für Tablet-Weitergabe.
- **PDF (Laufwege mit Zeit):** eine Übersichtsseite mit allen Laufwegen und
Abschnittszeiten, danach eine Seite pro Abschnitt. Dort sind die Laufwege
in Reihenfolge nummeriert; die Tabelle nennt Start, Ende, Dauer und
Element/Label. Lange Abschnitte werden auf weiteren Seiten fortgesetzt.
Abschnittszeiten, danach eine Seite pro Abschnitt. Die Zahlen im Rink
nummerieren die **Elemente** in Reihenfolge; die Tabelle hat eine Zeile pro
Element mit Start, Ende, Dauer und Element/Label. Sequenzbereiche nennen
zusätzlich ihre Teilstrecken-Anzahl. Reine Laufwege ohne Element stehen nur
im Rink. Lange Abschnitte werden auf weiteren Seiten fortgesetzt.
Bei „Aktiver Abschnitt“ entsteht nur die Seite dieses Abschnitts.
Nach dem Export erscheint der **absolute Dateipfad** mit den Buttons

View file

@ -20,6 +20,9 @@ Voraussetzung für Phase 1.
- [x] 2D-Rink-Canvas mit Meter→Pixel-Transform, Pan/Zoom und Touch-Pinch
- [x] Linien zeichnen, Richtung und Kante umschalten
- [x] Bogen-/Lobe-Vorlage mit automatischer Abflachung an der Bande
- [x] Freeline-Werkzeug für frei gezeichnete, mehrpunktige Laufwege
- [x] Freeline-Zwischenpunkte bearbeiten, glätten und per RDP reduzieren
- [x] Playback-Steuerung als Icon-Knöpfe (Start/Pause/Reset)
- [x] Auswahl, Start-/Endpunkt-Griffe, Bogen-Griff für Tiefe und Seite
- [x] Richtung/Kante auch nachträglich am ausgewählten Segment ändern
- [x] Segment löschen, Undo/Redo mit Snapshot-Historie
@ -121,6 +124,18 @@ Voraussetzung für Phase 1.
- [x] Tests für Marker-Modell, Interaktion und Export erweitern
- [ ] Optional: Elementkatalog mit Kürzelvorschlägen (Teil des ISU-Regelwerks)
### Erledigt: Step-Sequence-Gruppen (Option A)
- [x] `element_group_id` am Segment, Lead trägt die Elementdaten
- [x] `RoutineSection.get_elements()` / `ResolvedElement` als Auflösungsschicht
- [x] Validator, Adult-Regeln und Basiswert zählen eine Gruppe einmal
- [x] Sequenz-Zeichenmodus und Fortsetzen einer bestehenden Gruppe
- [x] Ein Gruppenlabel in Canvas und SVG
- [x] Schema 5 mit additivem `element_group_id`
- [x] Mehrfachauswahl und nachträgliches Gruppieren in der UI
- [x] PDF-Zeile pro Element statt pro Segment
- [ ] Gruppe teilen/zusammenführen
### In Arbeit: ISU-Regelwerk
- [x] Elementkatalog als strukturierte Daten (JSON/Resources)

View file

@ -0,0 +1,4 @@
<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32">
<rect x="9.5" y="7" width="4.5" height="18" rx="1.5" fill="#ffffff"/>
<rect x="18" y="7" width="4.5" height="18" rx="1.5" fill="#ffffff"/>
</svg>

After

Width:  |  Height:  |  Size: 234 B

View file

@ -0,0 +1,43 @@
[remap]
importer="texture"
type="CompressedTexture2D"
uid="uid://b5s4e4aaexpoh"
path="res://.godot/imported/pause.svg-8ec77cf881d30ecb6b3297b5f2a9e323.ctex"
metadata={
"vram_texture": false
}
[deps]
source_file="res://assets/icons/playback/pause.svg"
dest_files=["res://.godot/imported/pause.svg-8ec77cf881d30ecb6b3297b5f2a9e323.ctex"]
[params]
compress/mode=0
compress/high_quality=false
compress/lossy_quality=0.7
compress/uastc_level=0
compress/rdo_quality_loss=0.0
compress/hdr_compression=1
compress/normal_map=0
compress/channel_pack=0
mipmaps/generate=false
mipmaps/limit=-1
roughness/mode=0
roughness/src_normal=""
process/channel_remap/red=0
process/channel_remap/green=1
process/channel_remap/blue=2
process/channel_remap/alpha=3
process/fix_alpha_border=true
process/premult_alpha=false
process/normal_map_invert_y=false
process/hdr_as_srgb=false
process/hdr_clamp_exposure=false
process/size_limit=0
detect_3d/compress_to=1
svg/scale=1.0
editor/scale_with_editor_scale=false
editor/convert_colors_with_editor_theme=false

View file

@ -0,0 +1,4 @@
<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32">
<path d="M11 7 L26 16 L11 25 Z" fill="#ffffff" stroke="#ffffff" stroke-width="2"
stroke-linejoin="round"/>
</svg>

After

Width:  |  Height:  |  Size: 208 B

View file

@ -0,0 +1,43 @@
[remap]
importer="texture"
type="CompressedTexture2D"
uid="uid://dgw8yy1gph7sm"
path="res://.godot/imported/play.svg-c3fcc450e86ff851f726127b32d4ae01.ctex"
metadata={
"vram_texture": false
}
[deps]
source_file="res://assets/icons/playback/play.svg"
dest_files=["res://.godot/imported/play.svg-c3fcc450e86ff851f726127b32d4ae01.ctex"]
[params]
compress/mode=0
compress/high_quality=false
compress/lossy_quality=0.7
compress/uastc_level=0
compress/rdo_quality_loss=0.0
compress/hdr_compression=1
compress/normal_map=0
compress/channel_pack=0
mipmaps/generate=false
mipmaps/limit=-1
roughness/mode=0
roughness/src_normal=""
process/channel_remap/red=0
process/channel_remap/green=1
process/channel_remap/blue=2
process/channel_remap/alpha=3
process/fix_alpha_border=true
process/premult_alpha=false
process/normal_map_invert_y=false
process/hdr_as_srgb=false
process/hdr_clamp_exposure=false
process/size_limit=0
detect_3d/compress_to=1
svg/scale=1.0
editor/scale_with_editor_scale=false
editor/convert_colors_with_editor_theme=false

View file

@ -0,0 +1,5 @@
<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32">
<rect x="7.5" y="7" width="3" height="18" rx="1.5" fill="#ffffff"/>
<path d="M26 7 L12 16 L26 25 Z" fill="#ffffff" stroke="#ffffff" stroke-width="2"
stroke-linejoin="round"/>
</svg>

After

Width:  |  Height:  |  Size: 278 B

View file

@ -0,0 +1,43 @@
[remap]
importer="texture"
type="CompressedTexture2D"
uid="uid://jxlloyygkaxf"
path="res://.godot/imported/reset.svg-8e97fcb27c41573005b052e1d23da329.ctex"
metadata={
"vram_texture": false
}
[deps]
source_file="res://assets/icons/playback/reset.svg"
dest_files=["res://.godot/imported/reset.svg-8e97fcb27c41573005b052e1d23da329.ctex"]
[params]
compress/mode=0
compress/high_quality=false
compress/lossy_quality=0.7
compress/uastc_level=0
compress/rdo_quality_loss=0.0
compress/hdr_compression=1
compress/normal_map=0
compress/channel_pack=0
mipmaps/generate=false
mipmaps/limit=-1
roughness/mode=0
roughness/src_normal=""
process/channel_remap/red=0
process/channel_remap/green=1
process/channel_remap/blue=2
process/channel_remap/alpha=3
process/fix_alpha_border=true
process/premult_alpha=false
process/normal_map_invert_y=false
process/hdr_as_srgb=false
process/hdr_clamp_exposure=false
process/size_limit=0
detect_3d/compress_to=1
svg/scale=1.0
editor/scale_with_editor_scale=false
editor/convert_colors_with_editor_theme=false

View file

@ -0,0 +1,8 @@
<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32">
<path d="M5 26 C 9 20, 3 16, 8 12 C 13 8, 18 13, 13 17 C 8 21, 17 23, 22 15"
fill="none" stroke="#ffffff" stroke-width="2.4" stroke-linecap="round"/>
<g fill="none" stroke="#ffffff" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
<path d="M22 13 L27 8 L29.5 10.5 L24.5 15.5 Z"/>
<path d="M22 13 L20.5 17 L24.5 15.5 Z" fill="#ffffff"/>
</g>
</svg>

After

Width:  |  Height:  |  Size: 472 B

View file

@ -0,0 +1,43 @@
[remap]
importer="texture"
type="CompressedTexture2D"
uid="uid://m8rplqcxrmfj"
path="res://.godot/imported/freeline.svg-f278063a2344cce1155c320e4d6b13a9.ctex"
metadata={
"vram_texture": false
}
[deps]
source_file="res://assets/icons/tools/freeline.svg"
dest_files=["res://.godot/imported/freeline.svg-f278063a2344cce1155c320e4d6b13a9.ctex"]
[params]
compress/mode=0
compress/high_quality=false
compress/lossy_quality=0.7
compress/uastc_level=0
compress/rdo_quality_loss=0.0
compress/hdr_compression=1
compress/normal_map=0
compress/channel_pack=0
mipmaps/generate=false
mipmaps/limit=-1
roughness/mode=0
roughness/src_normal=""
process/channel_remap/red=0
process/channel_remap/green=1
process/channel_remap/blue=2
process/channel_remap/alpha=3
process/fix_alpha_border=true
process/premult_alpha=false
process/normal_map_invert_y=false
process/hdr_as_srgb=false
process/hdr_clamp_exposure=false
process/size_limit=0
detect_3d/compress_to=1
svg/scale=1.0
editor/scale_with_editor_scale=false
editor/convert_colors_with_editor_theme=false

View file

@ -1,11 +1,38 @@
[gd_scene load_steps=10 format=3]
[gd_scene load_steps=22 format=3]
[ext_resource type="Script" path="res://src/whiteboard/ctrl/whiteboard_controller.gd" id="1_controller"]
[ext_resource type="Script" path="res://src/whiteboard/view/rink_canvas.gd" id="2_canvas"]
[ext_resource type="Script" path="res://src/whiteboard/view/timeline_label_lane.gd" id="3_label_lane"]
[ext_resource type="Texture2D" path="res://assets/icons/tools/select.svg" id="4_tool_select"]
[ext_resource type="Texture2D" path="res://assets/icons/tools/line.svg" id="5_tool_line"]
[ext_resource type="Texture2D" path="res://assets/icons/tools/arc_left.svg" id="6_tool_arc_left"]
[ext_resource type="Texture2D" path="res://assets/icons/tools/arc_right.svg" id="7_tool_arc_right"]
[ext_resource type="Texture2D" path="res://assets/icons/tools/freeline.svg" id="11_tool_freeline"]
[ext_resource type="Texture2D" path="res://assets/icons/playback/play.svg" id="12_playback_play"]
[ext_resource type="Texture2D" path="res://assets/icons/playback/reset.svg" id="13_playback_reset"]
[ext_resource type="Texture2D" path="res://assets/icons/tools/jump.svg" id="8_tool_jump"]
[ext_resource type="Texture2D" path="res://assets/icons/tools/spin.svg" id="9_tool_spin"]
[ext_resource type="Texture2D" path="res://assets/icons/tools/sequence.svg" id="10_tool_sequence"]
[sub_resource type="ButtonGroup" id="ButtonGroup_direction"]
[sub_resource type="ButtonGroup" id="ButtonGroup_edge"]
[sub_resource type="ButtonGroup" id="ButtonGroup_tool"]
[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_tool_active"]
content_margin_left = 2.0
content_margin_top = 2.0
content_margin_right = 2.0
content_margin_bottom = 2.0
bg_color = Color(1, 1, 1, 0.08)
border_width_left = 2
border_width_top = 2
border_width_right = 2
border_width_bottom = 2
border_color = Color(1, 1, 1, 0.95)
corner_radius_top_left = 5
corner_radius_top_right = 5
corner_radius_bottom_right = 5
corner_radius_bottom_left = 5
[sub_resource type="StyleBoxFlat" id="StyleBoxFlat_top"]
content_margin_left = 16.0
@ -80,7 +107,7 @@ vertical_alignment = 1
[node name="FileMenuButton" type="MenuButton" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(80, 56)
custom_minimum_size = Vector2(64, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 15
text = "Datei"
@ -89,48 +116,186 @@ tooltip_text = "Datei"
[node name="TitleSeparator" type="VSeparator" parent="Layout/TopBar/Tools"]
layout_mode = 2
[node name="ToolLabel" type="Label" parent="Layout/TopBar/Tools"]
[node name="ToolButtons" type="HBoxContainer" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
layout_mode = 2
theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1)
theme_override_font_sizes/font_size = 15
text = "Werkzeug"
vertical_alignment = 1
theme_override_constants/separation = 4
[node name="ToolOption" type="OptionButton" parent="Layout/TopBar/Tools"]
[node name="SelectToolButton" type="Button" parent="Layout/TopBar/Tools/ToolButtons"]
unique_name_in_owner = true
custom_minimum_size = Vector2(170, 56)
custom_minimum_size = Vector2(44, 56)
icon_alignment = 1
layout_mode = 2
theme_override_font_sizes/font_size = 16
tooltip_text = "Auswählen"
toggle_mode = true
button_pressed = true
button_group = SubResource("ButtonGroup_tool")
theme_override_colors/icon_normal_color = Color(0.619608, 0.690196, 0.780392, 1)
theme_override_colors/icon_focus_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_hover_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 30
theme_override_styles/pressed = SubResource("StyleBoxFlat_tool_active")
theme_override_styles/hover_pressed = SubResource("StyleBoxFlat_tool_active")
icon = ExtResource("4_tool_select")
[node name="LineToolButton" type="Button" parent="Layout/TopBar/Tools/ToolButtons"]
unique_name_in_owner = true
custom_minimum_size = Vector2(44, 56)
icon_alignment = 1
layout_mode = 2
tooltip_text = "Linie"
toggle_mode = true
button_group = SubResource("ButtonGroup_tool")
theme_override_colors/icon_normal_color = Color(0.619608, 0.690196, 0.780392, 1)
theme_override_colors/icon_focus_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_hover_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 30
theme_override_styles/pressed = SubResource("StyleBoxFlat_tool_active")
theme_override_styles/hover_pressed = SubResource("StyleBoxFlat_tool_active")
icon = ExtResource("5_tool_line")
[node name="ArcLeftToolButton" type="Button" parent="Layout/TopBar/Tools/ToolButtons"]
unique_name_in_owner = true
custom_minimum_size = Vector2(44, 56)
icon_alignment = 1
layout_mode = 2
tooltip_text = "Bogen links"
toggle_mode = true
button_group = SubResource("ButtonGroup_tool")
theme_override_colors/icon_normal_color = Color(0.619608, 0.690196, 0.780392, 1)
theme_override_colors/icon_focus_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_hover_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 30
theme_override_styles/pressed = SubResource("StyleBoxFlat_tool_active")
theme_override_styles/hover_pressed = SubResource("StyleBoxFlat_tool_active")
icon = ExtResource("6_tool_arc_left")
[node name="ArcRightToolButton" type="Button" parent="Layout/TopBar/Tools/ToolButtons"]
unique_name_in_owner = true
custom_minimum_size = Vector2(44, 56)
icon_alignment = 1
layout_mode = 2
tooltip_text = "Bogen rechts"
toggle_mode = true
button_group = SubResource("ButtonGroup_tool")
theme_override_colors/icon_normal_color = Color(0.619608, 0.690196, 0.780392, 1)
theme_override_colors/icon_focus_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_hover_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 30
theme_override_styles/pressed = SubResource("StyleBoxFlat_tool_active")
theme_override_styles/hover_pressed = SubResource("StyleBoxFlat_tool_active")
icon = ExtResource("7_tool_arc_right")
[node name="FreeLineToolButton" type="Button" parent="Layout/TopBar/Tools/ToolButtons"]
unique_name_in_owner = true
custom_minimum_size = Vector2(44, 56)
icon_alignment = 1
layout_mode = 2
tooltip_text = "Freeline"
toggle_mode = true
button_group = SubResource("ButtonGroup_tool")
theme_override_colors/icon_normal_color = Color(0.619608, 0.690196, 0.780392, 1)
theme_override_colors/icon_focus_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_hover_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 30
theme_override_styles/pressed = SubResource("StyleBoxFlat_tool_active")
theme_override_styles/hover_pressed = SubResource("StyleBoxFlat_tool_active")
icon = ExtResource("11_tool_freeline")
[node name="JumpToolButton" type="Button" parent="Layout/TopBar/Tools/ToolButtons"]
unique_name_in_owner = true
custom_minimum_size = Vector2(44, 56)
icon_alignment = 1
layout_mode = 2
tooltip_text = "Sprung setzen"
toggle_mode = true
button_group = SubResource("ButtonGroup_tool")
theme_override_colors/icon_normal_color = Color(0.619608, 0.690196, 0.780392, 1)
theme_override_colors/icon_focus_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_hover_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 28
theme_override_styles/pressed = SubResource("StyleBoxFlat_tool_active")
theme_override_styles/hover_pressed = SubResource("StyleBoxFlat_tool_active")
icon = ExtResource("8_tool_jump")
[node name="SpinToolButton" type="Button" parent="Layout/TopBar/Tools/ToolButtons"]
unique_name_in_owner = true
custom_minimum_size = Vector2(44, 56)
icon_alignment = 1
layout_mode = 2
tooltip_text = "Pirouette setzen"
toggle_mode = true
button_group = SubResource("ButtonGroup_tool")
theme_override_colors/icon_normal_color = Color(0.619608, 0.690196, 0.780392, 1)
theme_override_colors/icon_focus_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_hover_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 28
theme_override_styles/pressed = SubResource("StyleBoxFlat_tool_active")
theme_override_styles/hover_pressed = SubResource("StyleBoxFlat_tool_active")
icon = ExtResource("9_tool_spin")
[node name="SequenceToolButton" type="Button" parent="Layout/TopBar/Tools/ToolButtons"]
unique_name_in_owner = true
custom_minimum_size = Vector2(44, 56)
icon_alignment = 1
layout_mode = 2
tooltip_text = "Sequenzbereich zeichnen"
toggle_mode = true
button_group = SubResource("ButtonGroup_tool")
theme_override_colors/icon_normal_color = Color(0.619608, 0.690196, 0.780392, 1)
theme_override_colors/icon_focus_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_hover_color = Color(0.890196, 0.933333, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 28
theme_override_styles/pressed = SubResource("StyleBoxFlat_tool_active")
theme_override_styles/hover_pressed = SubResource("StyleBoxFlat_tool_active")
icon = ExtResource("10_tool_sequence")
[node name="ToolSeparator" type="VSeparator" parent="Layout/TopBar/Tools"]
layout_mode = 2
[node name="ForwardButton" type="Button" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(96, 56)
custom_minimum_size = Vector2(88, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 16
toggle_mode = true
button_pressed = true
button_group = SubResource("ButtonGroup_direction")
text = "Vorwärts"
tooltip_text = "Vorwärts"
[node name="BackwardButton" type="Button" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(96, 56)
custom_minimum_size = Vector2(92, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 16
toggle_mode = true
button_group = SubResource("ButtonGroup_direction")
text = "Rückwärts"
tooltip_text = "Rückwärts"
[node name="EdgeSeparator" type="VSeparator" parent="Layout/TopBar/Tools"]
layout_mode = 2
[node name="InsideButton" type="Button" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(80, 56)
custom_minimum_size = Vector2(64, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 16
toggle_mode = true
@ -139,7 +304,7 @@ text = "Innen"
[node name="OutsideButton" type="Button" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(80, 56)
custom_minimum_size = Vector2(64, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 16
toggle_mode = true
@ -153,7 +318,7 @@ size_flags_horizontal = 3
[node name="UndoButton" type="Button" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(100, 56)
custom_minimum_size = Vector2(96, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 15
disabled = true
@ -162,7 +327,7 @@ tooltip_text = "Rückgängig (Strg+Z)"
[node name="RedoButton" type="Button" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(110, 56)
custom_minimum_size = Vector2(106, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 15
disabled = true
@ -171,7 +336,7 @@ tooltip_text = "Wiederholen (Strg+Shift+Z)"
[node name="FitButton" type="Button" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(96, 56)
custom_minimum_size = Vector2(90, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 16
text = "Einpassen"
@ -182,7 +347,7 @@ layout_mode = 2
[node name="View3DButton" type="Button" parent="Layout/TopBar/Tools"]
unique_name_in_owner = true
custom_minimum_size = Vector2(64, 56)
custom_minimum_size = Vector2(56, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 16
text = "3D"
@ -299,6 +464,30 @@ size_flags_horizontal = 3
theme_override_font_sizes/font_size = 15
text = "Abschnitt löschen"
[node name="GroupRow" type="VBoxContainer" parent="Layout/Content/SectionsPanel/SectionsVBox/Footer"]
layout_mode = 2
theme_override_constants/separation = 6
[node name="MultiSelectButton" type="Button" parent="Layout/Content/SectionsPanel/SectionsVBox/Footer/GroupRow"]
unique_name_in_owner = true
custom_minimum_size = Vector2(0, 56)
layout_mode = 2
size_flags_horizontal = 3
theme_override_font_sizes/font_size = 15
tooltip_text = "Mehrere Segmente durch Antippen auswählen"
toggle_mode = true
text = "Mehrfachauswahl"
[node name="GroupSequenceButton" type="Button" parent="Layout/Content/SectionsPanel/SectionsVBox/Footer/GroupRow"]
unique_name_in_owner = true
custom_minimum_size = Vector2(0, 56)
layout_mode = 2
size_flags_horizontal = 3
theme_override_font_sizes/font_size = 15
tooltip_text = "Ausgewählte zusammenhängende Segmente zu einer Schrittsequenz zusammenfassen"
disabled = true
text = "Sequenz gruppieren"
[node name="TimingBar" type="PanelContainer" parent="Layout"]
unique_name_in_owner = true
custom_minimum_size = Vector2(0, 72)
@ -345,6 +534,26 @@ disabled = true
text = "Element"
tooltip_text = "Elementtyp, Kürzel und Level für das ausgewählte Segment"
[node name="SmoothButton" type="Button" parent="Layout/TimingBar/TimingContent"]
unique_name_in_owner = true
visible = false
custom_minimum_size = Vector2(84, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 15
disabled = true
text = "Glätten"
tooltip_text = "Freeline weichzeichnen (mehrfach anwendbar)"
[node name="SimplifyButton" type="Button" parent="Layout/TimingBar/TimingContent"]
unique_name_in_owner = true
visible = false
custom_minimum_size = Vector2(116, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 15
disabled = true
text = "Vereinfachen"
tooltip_text = "Freeline auf die nötigen Punkte reduzieren"
[node name="ElementTypeOption" type="OptionButton" parent="Layout/TimingBar/TimingContent"]
unique_name_in_owner = true
custom_minimum_size = Vector2(132, 56)
@ -466,21 +675,31 @@ theme_override_constants/separation = 8
[node name="PlayButton" type="Button" parent="Layout/PlaybackBar/PlaybackContent"]
unique_name_in_owner = true
custom_minimum_size = Vector2(80, 56)
custom_minimum_size = Vector2(56, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 15
icon_alignment = 1
disabled = true
text = "Start"
tooltip_text = "Abspielen"
theme_override_colors/icon_normal_color = Color(0.85098, 0.890196, 0.941176, 1)
theme_override_colors/icon_hover_color = Color(1, 1, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 26
icon = ExtResource("12_playback_play")
[node name="ResetPlaybackButton" type="Button" parent="Layout/PlaybackBar/PlaybackContent"]
unique_name_in_owner = true
custom_minimum_size = Vector2(80, 56)
custom_minimum_size = Vector2(56, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 15
icon_alignment = 1
disabled = true
text = "Reset"
tooltip_text = "Zurücksetzen"
theme_override_colors/icon_normal_color = Color(0.85098, 0.890196, 0.941176, 1)
theme_override_colors/icon_hover_color = Color(1, 1, 1, 1)
theme_override_colors/icon_pressed_color = Color(1, 1, 1, 1)
theme_override_colors/icon_disabled_color = Color(0.337255, 0.380392, 0.443137, 1)
theme_override_constants/icon_max_width = 26
icon = ExtResource("13_playback_reset")
[node name="PlaybackTimeLabel" type="Label" parent="Layout/PlaybackBar/PlaybackContent"]
unique_name_in_owner = true
@ -788,21 +1007,76 @@ 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="ElementDurationLabel" type="Label" parent="ElementDialog/ElementBox"]
[node name="MarkerTimingRow" type="HBoxContainer" parent="ElementDialog/ElementBox"]
layout_mode = 2
theme_override_constants/separation = 12
[node name="DurationBox" type="VBoxContainer" parent="ElementDialog/ElementBox/MarkerTimingRow"]
layout_mode = 2
size_flags_horizontal = 3
theme_override_constants/separation = 4
[node name="ElementDurationLabel" type="Label" parent="ElementDialog/ElementBox/MarkerTimingRow/DurationBox"]
layout_mode = 2
theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1)
theme_override_font_sizes/font_size = 15
text = "Standzeit in Sekunden (nur Punktmarker)"
text = "Standzeit (s)"
[node name="ElementDurationSpin" type="SpinBox" parent="ElementDialog/ElementBox"]
[node name="ElementDurationSpin" type="SpinBox" parent="ElementDialog/ElementBox/MarkerTimingRow/DurationBox"]
unique_name_in_owner = true
custom_minimum_size = Vector2(0, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 17
tooltip_text = "Standzeit des Punktmarkers in Sekunden"
max_value = 120.0
step = 0.1
suffix = " s"
[node name="RevolutionsBox" type="VBoxContainer" parent="ElementDialog/ElementBox/MarkerTimingRow"]
unique_name_in_owner = true
visible = false
layout_mode = 2
size_flags_horizontal = 3
theme_override_constants/separation = 4
[node name="ElementRevolutionsLabel" type="Label" parent="ElementDialog/ElementBox/MarkerTimingRow/RevolutionsBox"]
unique_name_in_owner = true
layout_mode = 2
theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1)
theme_override_font_sizes/font_size = 15
text = "Umdrehungen · 0,0 U/s"
[node name="ElementRevolutionsSpin" type="SpinBox" parent="ElementDialog/ElementBox/MarkerTimingRow/RevolutionsBox"]
unique_name_in_owner = true
custom_minimum_size = Vector2(0, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 17
tooltip_text = "Geplante Umdrehungen. Die Anzeige dreht mit Umdrehungen / Standzeit."
min_value = 1.0
max_value = 120.0
step = 1.0
suffix = " U"
[node name="RotationBox" type="VBoxContainer" parent="ElementDialog/ElementBox/MarkerTimingRow"]
unique_name_in_owner = true
visible = false
layout_mode = 2
size_flags_horizontal = 3
theme_override_constants/separation = 4
[node name="ElementRotationLabel" type="Label" parent="ElementDialog/ElementBox/MarkerTimingRow/RotationBox"]
layout_mode = 2
theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1)
theme_override_font_sizes/font_size = 15
text = "Drehrichtung"
[node name="ElementRotationOption" type="OptionButton" parent="ElementDialog/ElementBox/MarkerTimingRow/RotationBox"]
unique_name_in_owner = true
custom_minimum_size = Vector2(0, 56)
layout_mode = 2
theme_override_font_sizes/font_size = 17
tooltip_text = "Drehrichtung der Pirouette. Die meisten Läufer drehen linksherum."
[node name="ElementHint" type="Label" parent="ElementDialog/ElementBox"]
custom_minimum_size = Vector2(480, 0)
layout_mode = 2

View file

@ -318,6 +318,7 @@ static func _encode_segment(segment: PathSegment) -> Dictionary:
return {
"segment_id": segment.segment_id,
"element_group_id": segment.element_group_id,
"direction": _direction_name(segment.direction),
"edge": _edge_name(segment.edge),
"duration_seconds": segment.duration_seconds,
@ -336,6 +337,14 @@ static func _encode_segment(segment: PathSegment) -> Dictionary:
"jump_kind": _jump_kind_name(segment.jump_kind),
"combination_jumps": combination,
"duration_seconds": segment.element_duration_seconds,
"revolutions": segment.element_revolutions,
"rotation_direction": _rotation_direction_name(
segment.element_rotation_direction
),
"jump_vector": [
segment.element_jump_vector.x,
segment.element_jump_vector.y,
],
},
"curve": {
"bake_interval": (
@ -412,6 +421,11 @@ static func _decode_segment(data: Dictionary) -> Dictionary:
segment.segment_id = _text(data, "segment_id", "").left(MAX_TEXT_LENGTH)
if segment.segment_id.is_empty():
return _error("Ein Segment hat keine ID.")
segment.element_group_id = _text(
data,
"element_group_id",
""
).strip_edges().left(PathSegment.ELEMENT_GROUP_ID_MAX_LENGTH)
var direction := _direction_from_name(_text(data, "direction", "forward"))
if direction < 0:
@ -480,6 +494,15 @@ static func _decode_segment(data: Dictionary) -> Dictionary:
0.0,
PathSegment.ELEMENT_MAX_DURATION_SECONDS
)
segment.set_element_revolutions(_number(element, "revolutions", 0.0))
segment.element_rotation_direction = _rotation_direction_from_name(
_text(element, "rotation_direction", "ccw")
)
var vector_value: Variant = element.get("jump_vector", null)
if vector_value is Array and (vector_value as Array).size() >= 2:
segment.set_element_jump_vector(
Vector2(float(vector_value[0]), float(vector_value[1]))
)
var features_value: Variant = element.get("features", [])
if not features_value is Array:
@ -759,6 +782,8 @@ static func _template_name(value: PathSegment.Template) -> String:
match value:
PathSegment.Template.ARC:
return "arc"
PathSegment.Template.FREEHAND:
return "freehand"
return "line"
@ -768,6 +793,8 @@ static func _template_from_name(value: String) -> int:
return PathSegment.Template.LINE
"arc":
return PathSegment.Template.ARC
"freehand":
return PathSegment.Template.FREEHAND
return -1
@ -795,6 +822,20 @@ static func _element_type_from_name(value: String) -> int:
return -1
static func _rotation_direction_name(
value: PathSegment.RotationDirection
) -> String:
if value == PathSegment.RotationDirection.CLOCKWISE:
return "cw"
return "ccw"
static func _rotation_direction_from_name(value: String) -> int:
if value.strip_edges().to_lower() == "cw":
return PathSegment.RotationDirection.CLOCKWISE
return PathSegment.RotationDirection.COUNTERCLOCKWISE
static func _jump_kind_name(value: PathSegment.JumpKind) -> String:
match value:
PathSegment.JumpKind.COMBINATION:

View file

@ -19,6 +19,7 @@ enum Edge {
enum Template {
LINE,
ARC,
FREEHAND,
}
enum TimingMode {
@ -42,11 +43,25 @@ enum JumpKind {
SEQUENCE,
}
## Direction a spin rotates on the ice. Counterclockwise is the common
## direction for most skaters (~85-90 %), so it is the default.
enum RotationDirection {
COUNTERCLOCKWISE,
CLOCKWISE,
}
const ELEMENT_CODE_MAX_LENGTH := 24
const ELEMENT_GROUP_ID_MAX_LENGTH := 64
const ELEMENT_MAX_LEVEL := 4
const ELEMENT_MAX_DURATION_SECONDS := 120.0
const ELEMENT_MAX_REVOLUTIONS := 120.0
const ELEMENT_MAX_FEATURES := 16
const JUMP_MAX_PARTS := 3
## Planning heuristic: a jump travels about one metre per air revolution. Used
## for the jump vector arrow until the user drags its tip.
const JUMP_METERS_PER_REVOLUTION := 1.0
## Longest allowed jump vector, in metres.
const ELEMENT_MAX_JUMP_DISTANCE_M := 30.0
@export var segment_id: String = ""
@export var curve: Curve2D
@ -56,6 +71,10 @@ const JUMP_MAX_PARTS := 3
@export var speed_mps: float = 4.3
@export var timing_mode: TimingMode = TimingMode.SPEED
@export var element_id: String = ""
## Segments that together form one element share this group id. Exactly one
## segment (the lead) carries the element data; the other members are plain
## path pieces of the same sequence range.
@export var element_group_id: String = ""
@export var element_type: ElementType = ElementType.NONE
@export var element_code: String = ""
## Structured jump combination: [member element_code] is the first jump,
@ -72,6 +91,19 @@ const JUMP_MAX_PARTS := 3
## 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
## Planned revolutions of a spin marker. The 2D/3D playback derives the rotation
## speed as element_revolutions / element_duration_seconds. Zero means the file
## predates this field (or no count is planned); the playback then uses its
## default visual rate.
@export var element_revolutions: float = 0.0
## Rotation direction of a spin marker. Defaults to counterclockwise.
@export var element_rotation_direction: RotationDirection = (
RotationDirection.COUNTERCLOCKWISE
)
## Explicit jump vector in rink coordinates (tip relative to the jump marker).
## Zero means "derive from the approach heading and the jump code"; dragging
## the arrow tip stores a vector here.
@export var element_jump_vector: Vector2 = Vector2.ZERO
@export var label: String = ""
## Geometry metadata. Start and end are always the first and last curve points;
@ -139,6 +171,16 @@ func is_element() -> bool:
return element_type != ElementType.NONE
## True for a plain path piece that only belongs to an element group. The lead
## segment carries the element data and the same [member element_group_id].
func is_element_member() -> bool:
return not element_group_id.is_empty() and element_type == ElementType.NONE
func is_element_lead() -> bool:
return not element_group_id.is_empty() and element_type != ElementType.NONE
static func element_type_name(type: ElementType) -> String:
match type:
ElementType.JUMP:
@ -156,6 +198,12 @@ static func element_type_name(type: ElementType) -> String:
func set_element(type: ElementType, code: String, level: int) -> void:
var previous_type := element_type
element_type = type
if type != ElementType.SPIN:
element_revolutions = 0.0
if type != ElementType.JUMP:
element_jump_vector = Vector2.ZERO
if type == ElementType.NONE or type == ElementType.SEQUENCE:
element_rotation_direction = RotationDirection.COUNTERCLOCKWISE
if type == ElementType.NONE:
element_code = ""
element_level = 0
@ -327,6 +375,78 @@ func set_element_duration(seconds: float) -> void:
)
## Clamps the planned revolution count of a spin marker.
func set_element_revolutions(count: float) -> void:
element_revolutions = clampf(count, 0.0, ELEMENT_MAX_REVOLUTIONS)
## Planned rotation speed of a spin marker in revolutions per second. Returns 0
## when the marker has no planned count or no stand time; callers then fall back
## to their default visual rate.
func get_spin_revolutions_per_second() -> float:
if element_type != ElementType.SPIN or element_duration_seconds <= 0.0:
return 0.0
if element_revolutions <= 0.0:
return 0.0
return element_revolutions / element_duration_seconds
## Angular sign for the playback. Godot's 2D screen space has y pointing down,
## so positive angles rotate clockwise; counterclockwise rotations return -1.
func get_rotation_sign() -> float:
if element_rotation_direction == RotationDirection.CLOCKWISE:
return 1.0
return -1.0
## Air revolutions of a jump, derived from the code: "3Lz" is three turns,
## "2A" is 2.5 (Axel adds half a turn). Unknown codes fall back to one turn.
func get_jump_revolutions() -> float:
if element_type != ElementType.JUMP:
return 0.0
var code := element_code.strip_edges()
var parts := get_jump_parts()
if not parts.is_empty():
code = str(parts[0]).strip_edges()
if code.is_empty():
return 1.0
var first := code.substr(0, 1)
if not first.is_valid_int():
return 1.0
var revolutions := float(first.to_int())
if is_axel(code):
revolutions += 0.5
return clampf(revolutions, 0.5, 4.5)
## Horizontal distance covered by the jump. Uses the explicit vector when the
## tip was dragged, otherwise the code-based planning heuristic.
func get_jump_distance_m() -> float:
if element_type != ElementType.JUMP:
return 0.0
if has_jump_vector():
return element_jump_vector.length()
return get_jump_revolutions() * JUMP_METERS_PER_REVOLUTION
## True when the jump vector was set explicitly (arrow tip dragged).
func has_jump_vector() -> bool:
return element_jump_vector.length_squared() > 0.000001
## Stores the dragged jump vector and clamps it to a plausible length.
func set_element_jump_vector(vector: Vector2) -> void:
if vector.length() > ELEMENT_MAX_JUMP_DISTANCE_M:
vector = vector.normalized() * ELEMENT_MAX_JUMP_DISTANCE_M
element_jump_vector = vector
static func rotation_direction_name(direction: RotationDirection) -> String:
if direction == RotationDirection.CLOCKWISE:
return "rechtsherum"
return "linksherum"
## Time this segment occupies on the timeline. Point markers use their element
## stand time, everything else the segment duration.
func get_effective_duration_seconds() -> float:
@ -339,6 +459,10 @@ func is_arc() -> bool:
return template == Template.ARC
func is_freehand() -> bool:
return template == Template.FREEHAND
func validate() -> PackedStringArray:
var errors := PackedStringArray()
@ -362,6 +486,15 @@ func validate() -> PackedStringArray:
)
if element_type == ElementType.NONE and not element_code.strip_edges().is_empty():
errors.append("element_code needs an element_type")
if element_group_id != element_group_id.strip_edges():
errors.append("element_group_id must be trimmed")
if element_group_id.length() > ELEMENT_GROUP_ID_MAX_LENGTH:
errors.append(
"element_group_id must not exceed %d characters"
% ELEMENT_GROUP_ID_MAX_LENGTH
)
if is_element_member() and is_marker():
errors.append("element group members must have a length")
if element_type == ElementType.NONE and not element_features.is_empty():
errors.append("element_features need an element_type")
if element_features.size() > ELEMENT_MAX_FEATURES:
@ -416,6 +549,26 @@ func validate() -> PackedStringArray:
"element_duration_seconds must be between 0 and %d"
% int(ELEMENT_MAX_DURATION_SECONDS)
)
if (
element_revolutions < 0.0
or element_revolutions > ELEMENT_MAX_REVOLUTIONS
):
errors.append(
"element_revolutions must be between 0 and %d"
% int(ELEMENT_MAX_REVOLUTIONS)
)
if element_type != ElementType.SPIN and element_revolutions > 0.0:
errors.append("only spins may plan revolutions")
if element_jump_vector.length() > ELEMENT_MAX_JUMP_DISTANCE_M:
errors.append(
"element_jump_vector must not exceed %d m"
% int(ELEMENT_MAX_JUMP_DISTANCE_M)
)
if (
element_rotation_direction != RotationDirection.COUNTERCLOCKWISE
and element_rotation_direction != RotationDirection.CLOCKWISE
):
errors.append("element_rotation_direction must be a valid direction")
if template == Template.ARC:
if arc_depth_ratio <= 0.0 or arc_depth_ratio >= 0.5:
errors.append("arc_depth_ratio must be between 0 and 0.5")

View file

@ -0,0 +1,177 @@
class_name ResolvedElement
extends RefCounted
## Read-only view of one scoring element. Option A keeps the element data on a
## lead [PathSegment]; the other segments only share [member
## PathSegment.element_group_id]. Point elements are resolved as a group of one,
## so callers do not need to special-case markers.
var element_id: String = ""
var section_id: String = ""
var segments: Array[PathSegment] = []
func get_lead() -> PathSegment:
for segment: PathSegment in segments:
if segment != null and segment.is_element():
return segment
if segments.is_empty():
return null
return segments[0]
func get_type() -> PathSegment.ElementType:
var lead := get_lead()
return lead.element_type if lead != null else PathSegment.ElementType.NONE
func get_code() -> String:
var lead := get_lead()
return lead.element_code if lead != null else ""
func get_level() -> int:
var lead := get_lead()
return lead.element_level if lead != null else 0
func get_features() -> PackedStringArray:
var lead := get_lead()
return lead.element_features.duplicate() if lead != null else PackedStringArray()
func get_caption() -> String:
var lead := get_lead()
return lead.get_element_caption() if lead != null else ""
func is_point_marker() -> bool:
return segments.size() == 1 and segments[0] != null and segments[0].is_element_marker()
func is_sequence_range() -> bool:
return not is_point_marker() and get_type() == PathSegment.ElementType.SEQUENCE
## Time this element occupies on the timeline. Point elements use their stand
## time, sequence ranges sum the duration of all member segments.
func get_duration_seconds() -> float:
var total := 0.0
for segment: PathSegment in segments:
if segment != null:
total += segment.get_effective_duration_seconds()
return total
func get_length_m() -> float:
var total := 0.0
for segment: PathSegment in segments:
if segment != null:
total += segment.get_length_m()
return total
func is_group() -> bool:
return (
not segments.is_empty()
and not segments[0].element_group_id.is_empty()
)
## Id shared by the group members. Empty for a standalone element.
func get_group_id() -> String:
if segments.is_empty():
return ""
return segments[0].element_group_id
func get_segment_ids() -> PackedStringArray:
var ids := PackedStringArray()
for segment: PathSegment in segments:
if segment != null:
ids.append(segment.segment_id)
return ids
## Point halfway along the group path, used for one caption per sequence range.
func get_midpoint() -> Vector2:
var anchor := get_anchor()
var point: Vector2 = anchor["point"]
return point
func get_midpoint_tangent() -> Vector2:
var anchor := get_anchor()
var tangent: Vector2 = anchor["tangent"]
return tangent
func get_anchor() -> Dictionary:
var total := get_length_m()
if total <= 0.0:
var lead := get_lead()
if lead != null and lead.curve != null and lead.curve.point_count > 0:
return {
"point": lead.curve.get_point_position(0),
"tangent": Vector2.RIGHT,
}
return {"point": Vector2.ZERO, "tangent": Vector2.RIGHT}
var target := total * 0.5
var covered := 0.0
for segment: PathSegment in segments:
if segment == null or segment.curve == null:
continue
var length := segment.get_length_m()
if length <= 0.0:
continue
if target <= covered + length or segment == segments[segments.size() - 1]:
var local := clampf(target - covered, 0.0, length)
var point := segment.curve.sample_baked(local)
var ahead := segment.curve.sample_baked(minf(length, local + 0.5))
var tangent := ahead - point
if tangent.length_squared() <= 0.0001:
tangent = Vector2.RIGHT
return {"point": point, "tangent": tangent.normalized()}
covered += length
var lead := get_lead()
if lead != null and lead.curve != null and lead.curve.point_count > 0:
return {
"point": lead.curve.get_point_position(0),
"tangent": Vector2.RIGHT,
}
return {"point": Vector2.ZERO, "tangent": Vector2.RIGHT}
func validate() -> PackedStringArray:
var errors := PackedStringArray()
if element_id.is_empty():
errors.append("element_id must not be empty")
if section_id.is_empty():
errors.append("section_id must not be empty")
if segments.is_empty():
errors.append("element must contain at least one segment")
return errors
var leads := 0
for segment: PathSegment in segments:
if segment == null:
errors.append("element contains a null segment")
continue
if segment.is_element():
leads += 1
if is_group() and segment.element_group_id != element_id:
errors.append(
"segment '%s' does not belong to group '%s'"
% [segment.segment_id, element_id]
)
if leads != 1:
errors.append("element group must have exactly one lead segment")
if segments.size() > 1 and get_type() != PathSegment.ElementType.SEQUENCE:
errors.append("only sequence ranges may span multiple segments")
return errors
func is_valid() -> bool:
return validate().is_empty()

View file

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

View file

@ -4,7 +4,7 @@ extends Resource
## Root aggregate of a choreography. Pure data: no rendering, no input, no
## timing state. The whiteboard view and the future 3D layer both consume it.
const CURRENT_SCHEMA_VERSION := 4
const CURRENT_SCHEMA_VERSION := 6
@export var schema_version: int = CURRENT_SCHEMA_VERSION
@export var routine_id: String = ""
@ -89,6 +89,7 @@ func validate() -> PackedStringArray:
var seen_section_ids: Dictionary[String, bool] = {}
var seen_orders: Dictionary[int, bool] = {}
var seen_segment_ids: Dictionary[String, bool] = {}
var seen_group_ids: Dictionary[String, bool] = {}
for section: RoutineSection in sections:
if section == null:
@ -98,6 +99,17 @@ func validate() -> PackedStringArray:
for error: String in section.validate():
errors.append("%s: %s" % [section.section_id, error])
for element: ResolvedElement in section.get_elements():
if element.segments.is_empty():
continue
if not element.segments[0].element_group_id.is_empty():
if seen_group_ids.has(element.element_id):
errors.append(
"duplicate element_group_id '%s'" % element.element_id
)
else:
seen_group_ids[element.element_id] = true
if seen_section_ids.has(section.section_id):
errors.append("duplicate section_id '%s'" % section.section_id)
else:

View file

@ -33,6 +33,77 @@ func get_segment_by_id(segment_id: String) -> PathSegment:
return null
## Resolves the scoring elements of this section. Standalone tagged segments
## become one-element groups, and contiguous segments that share an
## [member PathSegment.element_group_id] are merged. The lead segment carries
## the metadata; members only contribute geometry and duration.
func get_elements() -> Array[ResolvedElement]:
var result: Array[ResolvedElement] = []
var index := 0
while index < segments.size():
var segment: PathSegment = segments[index]
if segment == null:
index += 1
continue
if segment.element_group_id.is_empty():
if segment.is_element():
result.append(_make_element(segment.segment_id, [segment]))
index += 1
continue
var group_id := segment.element_group_id
var group: Array[PathSegment] = []
while index < segments.size():
var candidate: PathSegment = segments[index]
if candidate == null or candidate.element_group_id != group_id:
break
group.append(candidate)
index += 1
if _group_has_lead(group):
result.append(_make_element(group_id, group))
return result
func get_element_by_id(element_id: String) -> ResolvedElement:
for element: ResolvedElement in get_elements():
if element.element_id == element_id:
return element
return null
func get_element_for_segment(segment_id: String) -> ResolvedElement:
for element: ResolvedElement in get_elements():
for segment: PathSegment in element.segments:
if segment != null and segment.segment_id == segment_id:
return element
return null
func get_element_group_segments(group_id: String) -> Array[PathSegment]:
for element: ResolvedElement in get_elements():
if element.element_id == group_id:
return element.segments.duplicate()
return []
func _make_element(
element_id: String,
group: Array[PathSegment]
) -> ResolvedElement:
var element := ResolvedElement.new()
element.element_id = element_id
element.section_id = section_id
element.segments = group.duplicate()
return element
func _group_has_lead(group: Array[PathSegment]) -> bool:
for segment: PathSegment in group:
if segment != null and segment.is_element():
return true
return false
func validate() -> PackedStringArray:
var errors := PackedStringArray()
@ -55,6 +126,72 @@ func validate() -> PackedStringArray:
else:
seen_ids[segment.segment_id] = true
errors.append_array(_validate_element_groups())
return errors
func _validate_element_groups() -> PackedStringArray:
var errors := PackedStringArray()
var group_runs: Dictionary[String, Array] = {}
var group_order: Array[String] = []
var closed_groups: Dictionary[String, bool] = {}
var current_group := ""
for segment: PathSegment in segments:
if segment == null:
continue
var group_id := segment.element_group_id
if group_id.is_empty():
if not current_group.is_empty():
closed_groups[current_group] = true
current_group = ""
continue
if group_id != current_group:
if not current_group.is_empty():
closed_groups[current_group] = true
if closed_groups.has(group_id):
errors.append(
"element_group_id '%s' is split across non-adjacent segments"
% group_id
)
current_group = group_id
if not group_runs.has(group_id):
group_runs[group_id] = []
group_order.append(group_id)
var run: Array = group_runs[group_id]
run.append(segment)
group_runs[group_id] = run
for group_id: String in group_order:
var run: Array = group_runs[group_id]
var leads: Array[PathSegment] = []
for entry: Variant in run:
var segment: PathSegment = entry
if segment == null:
continue
if segment.is_element():
leads.append(segment)
if segment.is_marker():
errors.append(
"element group '%s' contains a zero-length segment"
% group_id
)
if leads.size() != 1:
errors.append(
"element group '%s' needs exactly one lead segment" % group_id
)
continue
var lead := leads[0]
if lead.element_type != PathSegment.ElementType.SEQUENCE:
errors.append(
"element group '%s' is only supported for sequence ranges"
% group_id
)
if run.size() > 1 and lead.is_marker():
errors.append(
"sequence range '%s' must contain path segments" % group_id
)
return errors

View file

@ -50,8 +50,9 @@ func validate_report(routine: Routine) -> ValidationReport:
if section == null:
continue
report.section_count += 1
for segment: PathSegment in section.segments:
if segment == null or not segment.is_element():
for element: ResolvedElement in section.get_elements():
var segment := element.get_lead()
if segment == null:
continue
report.element_count += 1
_validate_segment(segment, section.section_id, report)
@ -121,8 +122,9 @@ func _validate_category(
for section: RoutineSection in routine.sections:
if section == null:
continue
for segment: PathSegment in section.segments:
if segment == null or not segment.is_element():
for element: ResolvedElement in section.get_elements():
var segment := element.get_lead()
if segment == null:
continue
var code := segment.element_code.strip_edges()
var lower := code.to_lower()

File diff suppressed because it is too large Load diff

View file

@ -108,7 +108,7 @@ static func _append_section_pages(
routine: Routine,
entry: Dictionary
) -> void:
var rows: Array[Dictionary] = entry["rows"]
var rows: Array[Dictionary] = entry["elements"]
var index := 0
var first := true
while first or index < rows.size():
@ -145,7 +145,7 @@ static func _build_overview_page(
_clip_rect(lines, diagram)
var mapping := _draw_rink(lines, rink, diagram)
for entry: Dictionary in sections:
_draw_section_paths(lines, entry, mapping, false)
_draw_section_paths(lines, entry, mapping)
_draw_start_end_markers(lines, sections, mapping)
for index: int in range(sections.size()):
_draw_section_badge(lines, sections[index], mapping, index + 1)
@ -196,10 +196,11 @@ static func _build_section_page(
var title := "%d. %s" % [number, _section_title(section)]
if not first_page:
title += " · Fortsetzung"
var all_rows: Array[Dictionary] = entry["rows"]
var all_elements: Array[Dictionary] = entry["elements"]
var all_paths: Array[Dictionary] = entry["paths"]
var lines := _begin_page(
title,
_section_subtitle(entry, all_rows.size())
_section_subtitle(entry, all_elements.size(), all_paths.size())
)
if first_page:
@ -213,8 +214,9 @@ static func _build_section_page(
lines.append("q")
_clip_rect(lines, diagram)
var mapping := _draw_rink(lines, rink, diagram)
_draw_section_paths(lines, entry, mapping, true)
_draw_section_start_end(lines, all_rows, mapping)
_draw_section_paths(lines, entry, mapping)
_draw_element_badges(lines, entry, mapping)
_draw_section_start_end(lines, entry, mapping)
lines.append("Q")
_draw_legend(lines, MARGIN, diagram.end.y + 22.0)
_draw_note(
@ -222,13 +224,13 @@ static func _build_section_page(
MARGIN,
diagram.end.y + 78.0,
SECTION_DIAGRAM_WIDTH,
"Die Zahlen im Rink entsprechen der Reihenfolge in der Tabelle. "
+ "Die Tabelle nennt Start, Ende, Dauer und Element bzw. Label."
"Die Zahlen im Rink entsprechen der Reihenfolge der Elemente. "
+ "Reine Laufwege ohne Element stehen nur im Rink."
)
_draw_segment_table(lines, rows, TABLE_X, CONTENT_TOP, TABLE_WIDTH)
_draw_element_table(lines, rows, TABLE_X, CONTENT_TOP, TABLE_WIDTH)
else:
# Continuation pages use the full width for the remaining rows.
_draw_segment_table(
_draw_element_table(
lines,
rows,
MARGIN,
@ -248,54 +250,74 @@ static func _collect_sections(routine: Routine) -> Array[Dictionary]:
if section == null:
continue
var section_start := total
var rows: Array[Dictionary] = []
var index := 0
var paths: Array[Dictionary] = []
var segment_starts: Dictionary[String, float] = {}
for segment: PathSegment in section.segments:
if segment == null:
continue
index += 1
var duration := maxf(
segment.get_effective_duration_seconds(),
0.0
)
rows.append({
"index": index,
segment_starts[segment.segment_id] = total
paths.append({
"start": total,
"end": total + duration,
"duration": duration,
"text": _segment_text(segment),
"segment": segment,
})
total += duration
var elements: Array[Dictionary] = []
var element_index := 0
for element: ResolvedElement in section.get_elements():
var first_segment: PathSegment = null
for candidate: PathSegment in element.segments:
if candidate != null:
first_segment = candidate
break
if first_segment == null:
continue
var duration := maxf(element.get_duration_seconds(), 0.0)
var start := float(
segment_starts.get(first_segment.segment_id, section_start)
)
element_index += 1
elements.append({
"index": element_index,
"start": start,
"end": start + duration,
"duration": duration,
"text": _element_text(element),
"element": element,
})
result.append({
"number": result.size() + 1,
"section": section,
"start": section_start,
"end": total,
"duration": total - section_start,
"rows": rows,
"paths": paths,
"elements": elements,
})
return result
static func _segment_text(segment: PathSegment) -> String:
var text := segment.label.strip_edges()
if text.is_empty() and segment.is_element():
text = segment.get_element_caption().strip_edges()
## One table row per scoring element. Free-text labels on plain path segments
## are not part of the element table; the group suffix names its member count.
static func _element_text(element: ResolvedElement) -> String:
var lead := element.get_lead()
var label := lead.label.strip_edges() if lead != null else ""
var text := element.get_caption().strip_edges()
if text.is_empty():
if segment.is_arc():
text = "Bogen links" if segment.arc_bulge_left else "Bogen rechts"
else:
text = "Linie"
if not segment.is_element_marker():
var details := PackedStringArray()
if segment.direction == PathSegment.Direction.BACKWARD:
details.append("rückwärts")
if segment.edge == PathSegment.Edge.INSIDE:
details.append("innen")
if not details.is_empty():
text += " · " + ", ".join(details)
text = label
if text.is_empty():
text = PathSegment.element_type_name(element.get_type())
elif not label.is_empty() and label != text:
text += " · " + label
if element.segments.size() > 1:
text += " · %d Teile" % element.segments.size()
return text
@ -324,13 +346,17 @@ static func _routine_subtitle(routine: Routine, section_count: int) -> String:
return " · ".join(parts)
static func _section_subtitle(entry: Dictionary, row_count: int) -> String:
var section: RoutineSection = entry["section"]
return "Zeit %s–%s · Dauer %s · %d Segmente" % [
static func _section_subtitle(
entry: Dictionary,
element_count: int,
segment_count: int
) -> String:
return "Zeit %s–%s · Dauer %s · %d Elemente · %d Segmente" % [
_fmt_clock(float(entry["start"])),
_fmt_clock(float(entry["end"])),
_fmt_clock(float(entry["duration"])),
row_count,
element_count,
segment_count,
]
@ -750,27 +776,52 @@ static func _map_point(point: Vector2, mapping: Dictionary) -> Vector2:
static func _draw_section_paths(
lines: PackedStringArray,
entry: Dictionary,
mapping: Dictionary,
with_badges: bool
mapping: Dictionary
) -> void:
var rows: Array[Dictionary] = entry["rows"]
var rows: Array[Dictionary] = entry["paths"]
for row: Dictionary in rows:
var segment: PathSegment = row["segment"]
_draw_segment(
_draw_segment(lines, segment, mapping)
## Numbers in the rink identify elements, not individual path segments. A
## sequence range gets one badge at its mid-point, a point marker at its point.
static func _draw_element_badges(
lines: PackedStringArray,
entry: Dictionary,
mapping: Dictionary
) -> void:
var rows: Array[Dictionary] = entry["elements"]
for row: Dictionary in rows:
var element: ResolvedElement = row["element"]
var lead := element.get_lead()
if lead == null or lead.curve == null or lead.curve.point_count == 0:
continue
if element.is_point_marker():
var point := _map_point(lead.curve.get_point_position(0), mapping)
_draw_badge(lines, int(row["index"]), point + Vector2(10.0, 9.0))
continue
var anchor := element.get_anchor()
var model_point: Vector2 = anchor["point"]
var tangent: Vector2 = anchor["tangent"]
var mapped := _map_point(model_point, mapping)
var ahead := _map_point(model_point + tangent * 0.5, mapping)
var screen_tangent := ahead - mapped
if screen_tangent.length_squared() <= 0.0000001:
screen_tangent = Vector2.RIGHT
screen_tangent = screen_tangent.normalized()
var normal := Vector2(-screen_tangent.y, screen_tangent.x)
_draw_badge(
lines,
segment,
mapping,
int(row["index"]),
with_badges
mapped + normal * 9.0
)
static func _draw_segment(
lines: PackedStringArray,
segment: PathSegment,
mapping: Dictionary,
number: int,
with_badge: bool
mapping: Dictionary
) -> void:
if segment == null or segment.curve == null:
return
@ -780,19 +831,10 @@ static func _draw_segment(
if segment.is_element_marker():
var point := _map_point(segment.curve.get_point_position(0), mapping)
_draw_element_marker(lines, segment, point)
if with_badge:
_draw_badge(lines, number, point + Vector2(10.0, 9.0))
return
var length := segment.curve.get_baked_length()
if length <= 0.0:
if segment.curve.point_count > 0:
var point := _map_point(
segment.curve.get_point_position(0),
mapping
)
if with_badge:
_draw_badge(lines, number, point + Vector2(8.0, -8.0))
return
var color := _edge_color(segment)
@ -835,18 +877,6 @@ static func _draw_segment(
_reset_dash(lines)
_draw_arrow_head(lines, segment, mapping, color, width)
if with_badge:
var mid := curve.sample_baked(length * 0.5)
var before := curve.sample_baked(maxf(0.0, length * 0.5 - 0.5))
var after := curve.sample_baked(minf(length, length * 0.5 + 0.5))
var tangent := (after - before)
if tangent.length_squared() <= 0.0000001:
tangent = Vector2.RIGHT
tangent = tangent.normalized()
var normal := Vector2(-tangent.y, tangent.x)
var badge := _map_point(mid, mapping) + normal * 9.0
_draw_badge(lines, number, badge)
static func _draw_arrow_head(
lines: PackedStringArray,
@ -962,7 +992,7 @@ static func _draw_section_badge(
mapping: Dictionary,
number: int
) -> void:
var rows: Array[Dictionary] = entry["rows"]
var rows: Array[Dictionary] = entry["paths"]
for row: Dictionary in rows:
var segment: PathSegment = row["segment"]
if segment == null or segment.curve == null:
@ -991,7 +1021,7 @@ static func _draw_start_end_markers(
var start_point := Vector2.INF
var end_point := Vector2.INF
for entry: Dictionary in sections:
var rows: Array[Dictionary] = entry["rows"]
var rows: Array[Dictionary] = entry["paths"]
for row: Dictionary in rows:
var segment: PathSegment = row["segment"]
if segment == null or segment.curve == null:
@ -1028,11 +1058,12 @@ static func _draw_start_end_markers(
static func _draw_section_start_end(
lines: PackedStringArray,
rows: Array[Dictionary],
entry: Dictionary,
mapping: Dictionary
) -> void:
var first: PathSegment = null
var last: PathSegment = null
var rows: Array[Dictionary] = entry["paths"]
for row: Dictionary in rows:
var segment: PathSegment = row["segment"]
if segment == null or segment.curve == null:
@ -1161,7 +1192,7 @@ static func _draw_section_table(
)
static func _draw_segment_table(
static func _draw_element_table(
lines: PackedStringArray,
rows: Array[Dictionary],
x: float,

View file

@ -300,12 +300,46 @@ static func _add_segment_labels(
scale: float,
center: Vector2
) -> void:
var grouped_segments: Dictionary[String, bool] = {}
for section: RoutineSection in sections:
for element: ResolvedElement in section.get_elements():
if element.is_point_marker():
continue
var lead := element.get_lead()
if lead == null:
continue
var text := lead.label.strip_edges()
if text.is_empty():
text = element.get_caption().strip_edges()
for segment: PathSegment in element.segments:
if segment != null:
grouped_segments[segment.segment_id] = true
if text.is_empty():
continue
var anchor := element.get_anchor()
var mid_model: Vector2 = anchor["point"]
var tangent_model: Vector2 = anchor["tangent"]
_add_segment_label_text(
lines,
text,
mid_model,
mid_model + tangent_model * 0.5,
scale,
center
)
for section: RoutineSection in sections:
for segment: PathSegment in section.segments:
if segment == null or segment.curve == null:
continue
if segment.is_element_marker():
continue
if grouped_segments.has(segment.segment_id):
if segment.label.strip_edges().is_empty():
continue
var group := section.get_element_for_segment(segment.segment_id)
if group != null and group.get_lead() == segment:
continue
var text := segment.label.strip_edges()
if text.is_empty() and segment.is_element():
text = segment.get_element_caption()
@ -318,15 +352,26 @@ static func _add_segment_labels(
var ahead := segment.curve.sample_baked(
minf(length, length * 0.5 + 0.5)
)
var tangent := ahead - mid
if tangent.length_squared() < 0.0001:
tangent = Vector2.RIGHT
var normal := Vector2(-tangent.y, tangent.x).normalized()
var point := center + mid * scale + normal * 15.0
lines.append(
'<text x="%s" y="%s" font-family="sans-serif" font-size="13" fill="%s" stroke="#ffffff" stroke-width="3.5" paint-order="stroke" text-anchor="middle">%s</text>'
% [_n(point.x), _n(point.y), TEXT_COLOR, _escape(text)]
)
_add_segment_label_text(lines, text, mid, ahead, scale, center)
static func _add_segment_label_text(
lines: PackedStringArray,
text: String,
mid: Vector2,
ahead: Vector2,
scale: float,
center: Vector2
) -> void:
var tangent := ahead - mid
if tangent.length_squared() < 0.0001:
tangent = Vector2.RIGHT
var normal := Vector2(-tangent.y, tangent.x).normalized()
var point := center + mid * scale + normal * 15.0
lines.append(
'<text x="%s" y="%s" font-family="sans-serif" font-size="13" fill="%s" stroke="#ffffff" stroke-width="3.5" paint-order="stroke" text-anchor="middle">%s</text>'
% [_n(point.x), _n(point.y), TEXT_COLOR, _escape(text)]
)
static func _sample_curve(curve: Curve2D) -> PackedVector2Array:

View file

@ -13,16 +13,29 @@ signal draw_finished(model_point: Vector2)
signal draw_cancelled
signal marker_requested(model_point: Vector2)
signal segment_selected(segment_id: String)
signal segment_selection_toggled(segment_id: String)
signal selection_cleared
signal segment_handle_drag_started(segment_id: String, handle: int)
signal segment_handle_dragged(segment_id: String, handle: int, model_point: Vector2)
signal segment_handle_drag_finished(segment_id: String, handle: int, model_point: Vector2)
signal segment_handle_drag_started(segment_id: String, handle: int, detail: int)
signal segment_handle_dragged(
segment_id: String,
handle: int,
model_point: Vector2,
detail: int
)
signal segment_handle_drag_finished(
segment_id: String,
handle: int,
model_point: Vector2,
detail: int
)
enum Handle {
NONE,
START,
END,
BULGE,
JUMP_TIP,
FREEHAND_POINT,
}
const BACKGROUND_COLOR := Color("#0b1220")
@ -32,7 +45,7 @@ const CENTER_LINE_COLOR := Color("#dc2626")
const CIRCLE_COLOR := Color("#94a3b8")
const OUTSIDE_EDGE_COLOR := Color("#DC2626")
const INSIDE_EDGE_COLOR := Color("#2563EB")
const SELECTION_HALO_COLOR := Color(1.0, 1.0, 1.0, 0.5)
const SELECTION_HALO_COLOR := Color(0.98, 0.75, 0.14, 0.55)
const HANDLE_FILL_COLOR := Color("#f8fafc")
const HANDLE_BORDER_COLOR := Color("#0f172a")
const BULGE_HANDLE_COLOR := Color("#f59e0b")
@ -56,6 +69,11 @@ const MAX_CURVE_SAMPLES := 2000
const SEGMENT_HIT_RADIUS_PX := 14.0
const HANDLE_HIT_RADIUS_PX := 22.0
const HANDLE_RADIUS_PX := 7.0
## Freehand curves can have hundreds of points. Show a manageable subset as
## draggable nodes so the editor stays readable and hit-testing stays cheap.
const FREEHAND_HANDLE_LIMIT := 64
const FREEHAND_POINT_RADIUS_PX := 3.2
const FREEHAND_POINT_HIT_RADIUS_PX := 12.0
const TOUCH_MOUSE_GUARD_MSEC := 300
const SECTION_BANNER_DURATION := 2.0
const SECTION_BANNER_FADE_IN := 0.15
@ -87,9 +105,13 @@ var _pinch_distance: float = 0.0
var _selection_enabled: bool = false
var _marker_placement_enabled: bool = false
var _multi_select_enabled: bool = false
var _selected_segment_id: String = ""
var _selected_segment_ids: Array[String] = []
var _handle_drag: Handle = Handle.NONE
var _handle_drag_segment_id: String = ""
var _handle_detail: int = 0
var _handle_drag_detail: int = 0
var _handle_drag_started: bool = false
var _handle_touch_index: int = -1
var _last_handle_model_point: Vector2 = Vector2.ZERO
@ -100,6 +122,7 @@ var _playback_heading: Vector2 = Vector2.RIGHT
var _playback_section_id: String = ""
var _playback_edge: PathSegment.Edge = PathSegment.Edge.OUTSIDE
var _playback_direction: PathSegment.Direction = PathSegment.Direction.FORWARD
var _playback_marker_scale: float = 1.0
var _section_banner_text: String = ""
var _section_banner_elapsed: float = 0.0
@ -202,16 +225,57 @@ func is_marker_placement_enabled() -> bool:
func set_selected_segment(segment_id: String) -> void:
_selected_segment_id = segment_id
if segment_id.is_empty():
set_selected_segments(PackedStringArray(), "")
return
var ids := PackedStringArray()
ids.append(segment_id)
set_selected_segments(ids, segment_id)
func set_selected_segments(
segment_ids: PackedStringArray,
primary_id: String = ""
) -> void:
_selected_segment_ids.clear()
for segment_id: String in segment_ids:
if not segment_id.is_empty() and not _selected_segment_ids.has(segment_id):
_selected_segment_ids.append(segment_id)
if _selected_segment_ids.has(primary_id):
_selected_segment_id = primary_id
elif not _selected_segment_ids.is_empty():
_selected_segment_id = _selected_segment_ids[_selected_segment_ids.size() - 1]
else:
_selected_segment_id = ""
queue_redraw()
func get_selected_segment_ids() -> PackedStringArray:
var ids := PackedStringArray()
for segment_id: String in _selected_segment_ids:
ids.append(segment_id)
return ids
func set_multi_select_enabled(enabled: bool) -> void:
_multi_select_enabled = enabled
func is_multi_select_enabled() -> bool:
return _multi_select_enabled
func _is_selected(segment_id: String) -> bool:
return _selected_segment_ids.has(segment_id)
func set_playback_state(
position: Vector2,
heading: Vector2,
section_id: String,
edge: PathSegment.Edge,
direction: PathSegment.Direction
direction: PathSegment.Direction,
marker_scale: float = 1.0
) -> void:
_playback_visible = true
_playback_position = position
@ -219,12 +283,14 @@ func set_playback_state(
_playback_section_id = section_id
_playback_edge = edge
_playback_direction = direction
_playback_marker_scale = maxf(marker_scale, 1.0)
queue_redraw()
func clear_playback_state() -> void:
_playback_visible = false
_playback_section_id = ""
_playback_marker_scale = 1.0
hide_section_banner()
queue_redraw()
@ -233,6 +299,10 @@ func get_playback_section_id() -> String:
return _playback_section_id
func get_playback_marker_scale() -> float:
return _playback_marker_scale
## Shows the current section name at the top of the rink. It fades in briefly,
## stays readable and fades out before [param duration] seconds are over.
func show_section_banner(text: String, duration: float = SECTION_BANNER_DURATION) -> void:
@ -476,6 +546,7 @@ func _draw_section_badges() -> void:
func _draw_playback_marker() -> void:
var center := _transform.model_to_screen(_playback_position)
var radius := clampf(0.45 * _transform.pixels_per_meter, 8.0, 20.0)
radius = clampf(radius * _playback_marker_scale, 8.0, 44.0)
var marker_color := _edge_color(_playback_edge)
draw_circle(center, radius + 2.0, HANDLE_BORDER_COLOR)
@ -563,6 +634,7 @@ func _draw_section_banner() -> void:
func _draw_section(section: RoutineSection, alpha: float) -> void:
var step_px := GHOST_SAMPLE_STEP_PX if alpha < 1.0 else CURVE_SAMPLE_STEP_PX
var entry_heading := Vector2.RIGHT
for segment: PathSegment in section.segments:
if segment == null or segment.curve == null:
continue
@ -570,10 +642,35 @@ func _draw_section(section: RoutineSection, alpha: float) -> void:
_draw_element_marker(
segment,
alpha,
segment.segment_id == _selected_segment_id
_is_selected(segment.segment_id),
entry_heading
)
else:
_draw_segment(segment, alpha, step_px)
var heading := _segment_end_heading(segment)
if heading.length_squared() > 0.0:
entry_heading = heading
## Travel direction at the end of a path segment, used as the approach heading
## for a following jump marker.
func _segment_end_heading(segment: PathSegment) -> Vector2:
if segment.curve == null:
return Vector2.ZERO
var length := segment.get_length_m()
if length <= 0.0:
return Vector2.ZERO
var epsilon := maxf(0.01, length * 0.01)
var direction := (
segment.curve.sample_baked(length)
- segment.curve.sample_baked(maxf(0.0, length - epsilon))
)
if direction.length_squared() <= 0.0:
return Vector2.ZERO
direction = direction.normalized()
if segment.direction == PathSegment.Direction.BACKWARD:
direction = -direction
return direction
## Element markers show a type-specific shape at their point plus a short
@ -582,7 +679,8 @@ func _draw_section(section: RoutineSection, alpha: float) -> void:
func _draw_element_marker(
segment: PathSegment,
alpha: float,
selected: bool = false
selected: bool = false,
entry_heading: Vector2 = Vector2.RIGHT
) -> void:
if segment.curve == null or segment.curve.point_count == 0:
return
@ -596,12 +694,73 @@ func _draw_element_marker(
if selected:
draw_circle(center, radius + 5.0, SELECTION_HALO_COLOR)
_draw_element_shape(center, radius, segment.element_type, fill, border)
if segment.element_type == PathSegment.ElementType.JUMP:
_draw_jump_vector(
center,
radius,
_jump_vector(segment, entry_heading),
alpha
)
if not labels_visible:
return
_draw_element_caption(center + Vector2(0.0, -(radius + 14.0)), segment, alpha)
## Jump vector in model metres. Dragged tips are stored on the segment;
## otherwise the approach heading and the code-based distance are used.
func _jump_vector(segment: PathSegment, entry_heading: Vector2) -> Vector2:
if segment.element_jump_vector.length_squared() > 0.000001:
return segment.element_jump_vector
var heading := entry_heading
if heading.length_squared() <= 0.0:
heading = Vector2.RIGHT
return heading.normalized() * segment.get_jump_distance_m()
## Approach heading of a jump marker: end tangent of the last path segment
## before it in the active section.
func _jump_entry_heading(segment: PathSegment) -> Vector2:
var section := _get_active_section()
if section == null:
return Vector2.RIGHT
var heading := Vector2.RIGHT
for candidate: PathSegment in section.segments:
if candidate == segment:
break
if candidate == null or candidate.is_element_marker():
continue
var candidate_heading := _segment_end_heading(candidate)
if candidate_heading.length_squared() > 0.0:
heading = candidate_heading
return heading
## Draws a jump arrow from the marker centre to the landing point.
func _draw_jump_vector(
center: Vector2,
radius: float,
vector: Vector2,
alpha: float
) -> void:
var distance_m := vector.length()
if distance_m <= 0.0:
return
var heading := vector / distance_m
var tip := center + vector * _transform.pixels_per_meter
if tip.distance_squared_to(center) < radius * radius:
return
var color := ELEMENT_JUMP_COLOR
color.a *= alpha
draw_line(center, tip, color, 2.0, true)
var normal := Vector2(-heading.y, heading.x)
var head := clampf(tip.distance_to(center) * 0.28, 5.0, 10.0)
draw_line(tip, tip - heading * head + normal * head * 0.55, color, 2.0, true)
draw_line(tip, tip - heading * head - normal * head * 0.55, color, 2.0, true)
func _draw_element_shape(
center: Vector2,
radius: float,
@ -639,6 +798,10 @@ func _draw_element_caption(
alpha: float
) -> void:
var text := segment.get_element_caption()
if segment.element_type == PathSegment.ElementType.JUMP:
text += " · %s m" % (
("%.1f" % segment.get_jump_distance_m()).replace(".", ",")
)
var font := ThemeDB.fallback_font
var text_size := font.get_string_size(
text,
@ -692,14 +855,58 @@ func _element_color(type: PathSegment.ElementType) -> Color:
## section (or all sections in presentation mode) is labelled; ghosted
## sections are already too faint for readable text.
func _draw_section_labels(section: RoutineSection) -> void:
var grouped_segments: Dictionary[String, bool] = {}
for element: ResolvedElement in section.get_elements():
if element.is_point_marker():
continue
for segment: PathSegment in element.segments:
if segment != null:
grouped_segments[segment.segment_id] = true
_draw_element_group_label(element)
for segment: PathSegment in section.segments:
if segment == null or segment.curve == null:
continue
if segment.is_element_marker():
continue
if grouped_segments.has(segment.segment_id):
# The group caption already covers the lead. Free-text labels on
# other members stay visible.
if segment.label.strip_edges().is_empty():
continue
var group := section.get_element_for_segment(segment.segment_id)
if group != null and group.get_lead() == segment:
continue
_draw_segment_label(segment, _is_selected(segment.segment_id))
continue
if segment.label.strip_edges().is_empty() and not segment.is_element():
continue
_draw_segment_label(segment, segment.segment_id == _selected_segment_id)
_draw_segment_label(segment, _is_selected(segment.segment_id))
func _draw_element_group_label(element: ResolvedElement) -> void:
var lead := element.get_lead()
if lead == null:
return
var text := lead.label.strip_edges()
if text.is_empty():
text = element.get_caption()
if text.is_empty():
return
var anchor := element.get_anchor()
var model_point: Vector2 = anchor["point"]
var tangent: Vector2 = anchor["tangent"]
var selected := false
for segment: PathSegment in element.segments:
if segment != null and _is_selected(segment.segment_id):
selected = true
break
_draw_label_text(
text,
model_point,
model_point + tangent * 0.5,
selected
)
func _draw_segment_label(segment: PathSegment, selected: bool = false) -> void:
@ -709,6 +916,20 @@ func _draw_segment_label(segment: PathSegment, selected: bool = false) -> void:
var mid_model := segment.curve.sample_baked(length * 0.5)
var ahead_model := segment.curve.sample_baked(minf(length, length * 0.5 + 0.5))
var text := segment.label.strip_edges()
if text.is_empty() and segment.is_element():
text = segment.get_element_caption()
_draw_label_text(text, mid_model, ahead_model, selected)
func _draw_label_text(
text: String,
mid_model: Vector2,
ahead_model: Vector2,
selected: bool = false
) -> void:
if text.strip_edges().is_empty():
return
var mid := _transform.model_to_screen(mid_model)
var ahead := _transform.model_to_screen(ahead_model)
@ -717,9 +938,6 @@ func _draw_segment_label(segment: PathSegment, selected: bool = false) -> void:
tangent = Vector2.RIGHT
var normal := Vector2(-tangent.y, tangent.x).normalized()
var text := segment.label.strip_edges()
if text.is_empty() and segment.is_element():
text = segment.get_element_caption()
var font := ThemeDB.fallback_font
var font_size := 14
var text_size := font.get_string_size(
@ -800,19 +1018,17 @@ func _draw_segment(
func _draw_selection_highlight() -> void:
var segment := _get_selected_segment()
if segment == null:
return
var points := _sample_segment_screen(segment)
if points.size() < 2:
return
var halo_width := _segment_width() + 6.0
if segment.direction == PathSegment.Direction.BACKWARD:
_draw_dashed_polyline(points, SELECTION_HALO_COLOR, halo_width)
else:
draw_polyline(points, SELECTION_HALO_COLOR, halo_width, true)
for segment: PathSegment in _get_selected_segments():
if segment == null:
continue
var points := _sample_segment_screen(segment)
if points.size() < 2:
continue
if segment.direction == PathSegment.Direction.BACKWARD:
_draw_dashed_polyline(points, SELECTION_HALO_COLOR, halo_width)
else:
draw_polyline(points, SELECTION_HALO_COLOR, halo_width, true)
func _draw_selection_handles() -> void:
@ -822,10 +1038,17 @@ func _draw_selection_handles() -> void:
if segment.is_element_marker():
if segment.curve != null and segment.curve.point_count > 0:
_draw_handle(
_transform.model_to_screen(segment.curve.get_point_position(0)),
HANDLE_FILL_COLOR
var center := _transform.model_to_screen(
segment.curve.get_point_position(0)
)
_draw_handle(center, HANDLE_FILL_COLOR)
if segment.element_type == PathSegment.ElementType.JUMP:
var vector := _jump_vector(
segment,
_jump_entry_heading(segment)
)
var tip := center + vector * _transform.pixels_per_meter
_draw_handle(tip, ELEMENT_JUMP_COLOR)
return
var points := _sample_segment_screen(segment)
@ -837,6 +1060,10 @@ func _draw_selection_handles() -> void:
_draw_handle(start, HANDLE_FILL_COLOR)
_draw_handle(end, HANDLE_FILL_COLOR)
if segment.is_freehand():
_draw_freehand_point_handles(segment)
return
if not segment.is_arc():
return
@ -853,6 +1080,24 @@ func _draw_handle(center: Vector2, fill: Color) -> void:
draw_circle(center, HANDLE_RADIUS_PX, fill)
func _draw_freehand_point_handles(segment: PathSegment) -> void:
if segment == null or segment.curve == null:
return
var last_index := segment.curve.point_count - 1
for index: int in _freehand_handle_indices(segment):
if index <= 0 or index >= last_index:
continue
var center := _transform.model_to_screen(
segment.curve.get_point_position(index)
)
draw_circle(
center,
FREEHAND_POINT_RADIUS_PX + 2.0,
HANDLE_BORDER_COLOR
)
draw_circle(center, FREEHAND_POINT_RADIUS_PX, HANDLE_FILL_COLOR)
func _draw_dashed_polyline(
points: PackedVector2Array,
color: Color,
@ -1031,6 +1276,38 @@ func _get_selected_segment() -> PathSegment:
return active.get_segment_by_id(_selected_segment_id)
func _get_selected_segments() -> Array[PathSegment]:
var result: Array[PathSegment] = []
var active := _get_active_section()
if active == null:
return result
for segment_id: String in _selected_segment_ids:
var segment := active.get_segment_by_id(segment_id)
if segment != null:
result.append(segment)
return result
func _freehand_handle_indices(segment: PathSegment) -> PackedInt32Array:
var indices := PackedInt32Array()
if segment == null or segment.curve == null:
return indices
var count := segment.curve.point_count
if count <= 0:
return indices
if count <= FREEHAND_HANDLE_LIMIT:
for index: int in range(count):
indices.append(index)
return indices
for slot: int in range(FREEHAND_HANDLE_LIMIT):
var index := roundi(
float(slot) * float(count - 1) / float(FREEHAND_HANDLE_LIMIT - 1)
)
if indices.is_empty() or indices[indices.size() - 1] != index:
indices.append(index)
return indices
func _find_segment_at(screen_point: Vector2) -> PathSegment:
var active := _get_active_section()
if active == null:
@ -1077,6 +1354,7 @@ func _distance_to_polyline(
func _handle_at(screen_point: Vector2) -> Handle:
_handle_detail = 0
var segment := _get_selected_segment()
if segment == null:
return Handle.NONE
@ -1085,6 +1363,11 @@ func _handle_at(screen_point: Vector2) -> Handle:
if segment.curve == null or segment.curve.point_count == 0:
return Handle.NONE
var point := _transform.model_to_screen(segment.curve.get_point_position(0))
if segment.element_type == PathSegment.ElementType.JUMP:
var vector := _jump_vector(segment, _jump_entry_heading(segment))
var tip := point + vector * _transform.pixels_per_meter
if screen_point.distance_to(tip) <= HANDLE_HIT_RADIUS_PX:
return Handle.JUMP_TIP
if screen_point.distance_to(point) <= HANDLE_HIT_RADIUS_PX:
return Handle.START
return Handle.NONE
@ -1097,6 +1380,26 @@ func _handle_at(screen_point: Vector2) -> Handle:
return Handle.START
if screen_point.distance_to(points[points.size() - 1]) <= HANDLE_HIT_RADIUS_PX:
return Handle.END
if segment.is_freehand() and segment.curve != null:
var last_index := segment.curve.point_count - 1
var best_index := -1
var best_distance := INF
for index: int in _freehand_handle_indices(segment):
if index <= 0 or index >= last_index:
continue
var point := _transform.model_to_screen(
segment.curve.get_point_position(index)
)
var distance := screen_point.distance_to(point)
if (
distance <= FREEHAND_POINT_HIT_RADIUS_PX
and distance < best_distance
):
best_distance = distance
best_index = index
if best_index >= 0:
_handle_detail = best_index
return Handle.FREEHAND_POINT
if segment.is_arc():
if screen_point.distance_to(_curve_apex_screen(segment.curve)) <= HANDLE_HIT_RADIUS_PX:
return Handle.BULGE
@ -1156,7 +1459,13 @@ func _handle_mouse_button(event: InputEventMouseButton) -> void:
_panning = true
accept_event()
elif _selection_enabled:
_begin_selection_press(event.position)
_begin_selection_press(
event.position,
_multi_select_enabled
or event.shift_pressed
or event.ctrl_pressed
or event.meta_pressed
)
accept_event()
elif drawing_enabled and _begin_drawing(event.position):
accept_event()
@ -1182,7 +1491,8 @@ func _handle_mouse_motion(event: InputEventMouseMotion) -> void:
segment_handle_dragged.emit(
_handle_drag_segment_id,
_handle_drag,
_last_handle_model_point
_last_handle_model_point,
_handle_drag_detail
)
elif _drawing:
draw_updated.emit(_transform.screen_to_model(event.position))
@ -1190,21 +1500,26 @@ func _handle_mouse_motion(event: InputEventMouseMotion) -> void:
_apply_pan(event.relative)
func _begin_selection_press(screen_point: Vector2) -> void:
func _begin_selection_press(screen_point: Vector2, additive: bool = false) -> void:
_handle_drag_detail = 0
var handle := _handle_at(screen_point)
if handle != Handle.NONE:
_handle_drag = handle
_handle_drag_segment_id = _selected_segment_id
_handle_drag_detail = _handle_detail
_handle_drag_started = false
_last_handle_model_point = _transform.screen_to_model(screen_point)
return
var segment := _find_segment_at(screen_point)
if segment != null:
_select_segment(segment)
_select_segment(segment, additive)
return
_clear_selection()
# In additive/multi-select mode an empty press pans without dropping the
# current selection. Escape or a plain press clears it.
if not additive:
_clear_selection()
_panning = true
@ -1217,10 +1532,12 @@ func _finish_handle_drag(screen_point: Vector2) -> void:
segment_handle_drag_finished.emit(
_handle_drag_segment_id,
_handle_drag,
model_point
model_point,
_handle_drag_detail
)
_handle_drag = Handle.NONE
_handle_drag_segment_id = ""
_handle_drag_detail = 0
_handle_drag_started = false
@ -1230,7 +1547,11 @@ func _ensure_handle_drag_started() -> void:
if _handle_drag_started:
return
_handle_drag_started = true
segment_handle_drag_started.emit(_handle_drag_segment_id, _handle_drag)
segment_handle_drag_started.emit(
_handle_drag_segment_id,
_handle_drag,
_handle_drag_detail
)
func _abort_handle_drag() -> void:
@ -1241,22 +1562,47 @@ func _abort_handle_drag() -> void:
segment_handle_drag_finished.emit(
_handle_drag_segment_id,
_handle_drag,
_last_handle_model_point
_last_handle_model_point,
_handle_drag_detail
)
_handle_drag = Handle.NONE
_handle_drag_segment_id = ""
_handle_drag_detail = 0
_handle_drag_started = false
func _select_segment(segment: PathSegment) -> void:
_selected_segment_id = segment.segment_id
func _select_segment(segment: PathSegment, additive: bool = false) -> void:
var id := segment.segment_id
if additive:
if _selected_segment_ids.has(id):
_selected_segment_ids.erase(id)
if _selected_segment_id == id:
_selected_segment_id = (
_selected_segment_ids[_selected_segment_ids.size() - 1]
if not _selected_segment_ids.is_empty()
else ""
)
else:
_selected_segment_ids.append(id)
_selected_segment_id = id
queue_redraw()
if _selected_segment_ids.is_empty():
selection_cleared.emit()
else:
segment_selection_toggled.emit(id)
return
_selected_segment_ids.clear()
_selected_segment_ids.append(id)
_selected_segment_id = id
queue_redraw()
segment_selected.emit(segment.segment_id)
segment_selected.emit(id)
func _clear_selection() -> void:
if _selected_segment_id.is_empty():
if _selected_segment_ids.is_empty() and _selected_segment_id.is_empty():
return
_selected_segment_ids.clear()
_selected_segment_id = ""
queue_redraw()
selection_cleared.emit()
@ -1278,7 +1624,7 @@ func _handle_screen_touch(event: InputEventScreenTouch) -> void:
if not _request_marker(event.position):
_pan_touch_index = event.index
elif _selection_enabled:
_begin_selection_press(event.position)
_begin_selection_press(event.position, _multi_select_enabled)
if _handle_drag != Handle.NONE:
_handle_touch_index = event.index
elif _panning:
@ -1328,7 +1674,8 @@ func _handle_screen_drag(event: InputEventScreenDrag) -> void:
segment_handle_dragged.emit(
_handle_drag_segment_id,
_handle_drag,
_last_handle_model_point
_last_handle_model_point,
_handle_drag_detail
)
elif _drawing and event.index == _draw_touch_index:
draw_updated.emit(_transform.screen_to_model(event.position))

View file

@ -31,6 +31,7 @@ func _init() -> void:
_test_category_fields()
_test_jump_permissions()
_test_gold_limits()
_test_sequence_group_count()
_test_valid_gold()
_test_duration_and_repetitions()
_test_structured_jump()
@ -146,6 +147,34 @@ func _test_gold_limits() -> void:
_check(_has_message(report, "Choreographic Spin"), "choreo spin message")
func _test_sequence_group_count() -> void:
var routine := _make_routine("gold")
var section := routine.sections[0]
for index: int in range(3):
var segment: PathSegment = PathSegmentModel.new()
segment.segment_id = "seq-%d" % index
var curve := Curve2D.new()
curve.add_point(Vector2(float(index) * 2.0, 0.0))
curve.add_point(Vector2(float(index) * 2.0 + 1.0, 0.0))
segment.curve = curve
segment.set_speed_mps(4.3)
segment.element_group_id = "el-001"
if index == 0:
segment.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 0)
section.segments.append(segment)
var report := _validator.validate_report(routine)
_check(report.element_count == 1, "the sequence group counts as one element")
_check(
report.get_check("category_sequences").passed,
"a multi-segment step sequence stays within the category limit"
)
_check(
not _has_message(report, "Schrittsequenzen: 3"),
"the category does not count the group segments separately"
)
func _test_valid_gold() -> void:
var routine := _make_routine("gold")
var section := routine.sections[0]

View file

@ -33,6 +33,10 @@ func _run() -> void:
svg.contains(">3Lz &amp; &lt;Spin&gt;</text>"),
"SVG contains and escapes segment labels"
)
_check(
_count(svg, ">3Lz &amp; &lt;Spin&gt;</text>") == 1,
"SVG draws a sequence group label only once"
)
_check(
svg.contains('paint-order="stroke"'),
"SVG labels get a white outline"
@ -161,15 +165,19 @@ func _run() -> void:
long_section.title = "Langer Abschnitt"
long_section.sequence_order = 2
for index: int in range(30):
long_section.segments.append(
_make_segment(
"seg-long-%d" % index,
Vector2(-20.0 + float(index) * 0.5, -10.0),
Vector2(-19.5 + float(index) * 0.5, -10.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
var long_segment := _make_segment(
"seg-long-%d" % index,
Vector2(-20.0 + float(index) * 0.5, -10.0),
Vector2(-19.5 + float(index) * 0.5, -10.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
long_segment.set_element(
PathSegment.ElementType.SEQUENCE,
"StSq",
0
)
long_section.segments.append(long_segment)
long_routine.sections.append(long_section)
var long_pdf := RoutinePdfExporter.build(long_routine, "section-long")
_check(
@ -177,6 +185,8 @@ func _run() -> void:
"long PDF section continues on a second page"
)
_test_pdf_element_table()
var scene := WhiteboardScene.instantiate()
var controller := scene as WhiteboardController
if controller != null:
@ -297,6 +307,60 @@ func _run() -> void:
_finish()
func _test_pdf_element_table() -> void:
var routine := Routine.new()
routine.routine_id = "pdf-element-table"
routine.title = "PDF Elemente"
routine.rink = RinkDimensions.new()
var section := RoutineSection.new()
section.section_id = "section-elements"
section.title = "Sequenz"
section.sequence_order = 0
var first := _make_segment(
"seg-group-1",
Vector2(-20.0, 0.0),
Vector2(-10.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
first.element_group_id = "el-001"
first.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 1)
first.label = "Gruppe"
var second := _make_segment(
"seg-group-2",
Vector2(-10.0, 0.0),
Vector2(0.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.INSIDE
)
second.element_group_id = "el-001"
var plain := _make_segment(
"seg-plain",
Vector2(0.0, 0.0),
Vector2(10.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
plain.label = "NurPfad"
section.segments = [first, second, plain]
routine.sections = [section]
var pdf := RoutinePdfExporter.build(routine, section.section_id)
var text := pdf.get_string_from_ascii()
_check(text.contains("Gruppe"), "PDF table contains the element label")
_check(text.contains("StSq L1"), "PDF table shows the element code")
_check(text.contains("2 Teile"), "PDF table shows the sequence part count")
_check(
_count(text, "Gruppe") == 1,
"PDF table has one row per element instead of per segment"
)
_check(
not text.contains("NurPfad"),
"free-text labels of plain path segments are not table rows"
)
func _make_routine() -> Routine:
var routine := Routine.new()
routine.routine_id = "export-test"
@ -318,6 +382,16 @@ func _make_routine() -> Routine:
PathSegment.Edge.OUTSIDE
)
labelled.label = "3Lz & <Spin>"
labelled.element_group_id = "el-steps"
labelled.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 2)
var step_two := _make_segment(
"seg-2",
Vector2(-10.0, -8.0),
Vector2(0.0, 0.0),
PathSegment.Direction.BACKWARD,
PathSegment.Edge.INSIDE
)
step_two.element_group_id = "el-steps"
var spin_marker := _make_marker(
"seg-marker-spin",
Vector2(-5.0, 6.0),
@ -325,17 +399,7 @@ func _make_routine() -> Routine:
"CCoSp4",
3
)
section_one.segments = [
labelled,
_make_segment(
"seg-2",
Vector2(-10.0, -8.0),
Vector2(0.0, 0.0),
PathSegment.Direction.BACKWARD,
PathSegment.Edge.INSIDE
),
spin_marker,
]
section_one.segments = [labelled, step_two, spin_marker]
var section_two := RoutineSection.new()
section_two.section_id = "section-2"

View file

@ -40,6 +40,10 @@ func _test_json_roundtrip() -> void:
encoded.contains("\"direction\": \"backward\""),
"enums are stored as readable names"
)
_check(
encoded.contains("\"template\": \"freehand\""),
"freehand template is stored as a readable name"
)
var result := RoutineFile.decode_json(encoded)
_check(str(result["error"]).is_empty(), "encoded JSON decodes without error")
@ -82,7 +86,40 @@ func _test_json_roundtrip() -> void:
if section == null:
return
_check(section.title == "Abschnitt 1", "section title survives")
_check(section.segments.size() == 3, "all segments survive")
_check(section.segments.size() == 5, "all segments survive")
var sequence_lead := section.get_segment_by_id("seg-line")
var sequence_member := section.get_segment_by_id("seg-sequence-member")
_check(
sequence_lead != null
and sequence_lead.element_group_id == "el-001"
and sequence_lead.element_type == PathSegment.ElementType.SEQUENCE,
"sequence lead and group id survive"
)
_check(
sequence_member != null
and sequence_member.element_group_id == "el-001"
and sequence_member.element_type == PathSegment.ElementType.NONE,
"sequence member keeps its group id without element data"
)
_check(
section.get_elements().size() == 3,
"the loaded group resolves with the other elements"
)
var freehand := section.get_segment_by_id("seg-freehand")
_check(freehand != null, "freehand segment survives")
if freehand != null:
_check(
freehand.template == PathSegment.Template.FREEHAND,
"freehand template survives"
)
_check(freehand.curve.point_count == 3, "freehand points survive")
_check_vec(
freehand.curve.get_point_position(1),
Vector2(5.0, -8.0),
"freehand interior point survives"
)
var arc := section.get_segment_by_id("seg-arc")
_check(arc != null, "arc segment survives")
@ -102,6 +139,11 @@ func _test_json_roundtrip() -> void:
arc.element_features == PackedStringArray(["difficult_exit"]),
"features survive"
)
_check_vec(
arc.element_jump_vector,
Vector2(1.5, 0.5),
"jump vector survives"
)
_check(arc.curve.point_count == 2, "curve points survive")
_check_vec(
arc.curve.get_point_position(0),
@ -129,6 +171,16 @@ func _test_json_roundtrip() -> void:
0.7,
"marker stand time survives"
)
_check_approx(
marker.element_revolutions,
14.0,
"spin revolution count survives"
)
_check(
marker.element_rotation_direction
== PathSegment.RotationDirection.CLOCKWISE,
"spin rotation direction survives"
)
func _test_json_rejects() -> void:
@ -314,6 +366,16 @@ func _make_routine() -> Routine:
line.curve.add_point(Vector2(-15.0, 0.0))
line.curve.add_point(Vector2(-5.0, 0.0))
line.set_speed_mps(4.0)
line.element_group_id = "el-001"
line.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 0)
var sequence_member := PathSegment.new()
sequence_member.segment_id = "seg-sequence-member"
sequence_member.curve = Curve2D.new()
sequence_member.curve.add_point(Vector2(-5.0, 0.0))
sequence_member.curve.add_point(Vector2(0.0, 0.0))
sequence_member.set_speed_mps(4.0)
sequence_member.element_group_id = "el-001"
var arc := PathSegment.new()
arc.segment_id = "seg-arc"
@ -343,6 +405,16 @@ func _make_routine() -> Routine:
PathSegment.JumpKind.COMBINATION,
PackedStringArray(["2T", "2S"])
)
arc.set_element_jump_vector(Vector2(1.5, 0.5))
var freehand := PathSegment.new()
freehand.segment_id = "seg-freehand"
freehand.template = PathSegment.Template.FREEHAND
freehand.curve = Curve2D.new()
freehand.curve.add_point(Vector2(0.0, -10.0))
freehand.curve.add_point(Vector2(5.0, -8.0))
freehand.curve.add_point(Vector2(10.0, -11.0))
freehand.set_speed_mps(4.0)
var marker := PathSegment.new()
marker.segment_id = "seg-marker"
@ -351,8 +423,10 @@ func _make_routine() -> Routine:
marker.speed_mps = 4.0
marker.set_element(PathSegment.ElementType.SPIN, "CCoSp4", 4)
marker.set_element_duration(0.7)
marker.set_element_revolutions(14.0)
marker.element_rotation_direction = PathSegment.RotationDirection.CLOCKWISE
section.segments = [line, arc, marker]
section.segments = [line, sequence_member, arc, freehand, marker]
routine.sections = [section]
return routine

View file

@ -20,6 +20,7 @@ func _init() -> void:
_test_element_markers()
_test_jump_combinations()
_test_section_aggregation()
_test_element_groups()
_test_routine_validation()
_finish()
@ -192,6 +193,53 @@ func _test_element_markers() -> void:
PathSegmentModel.element_type_name(PathSegmentModel.ElementType.JUMP) == "Sprung",
"jump type has a German name"
)
_check_approx(
jump.get_jump_revolutions(),
3.0,
"a 3Lz turns three times in the air"
)
_check_approx(
jump.get_jump_distance_m(),
3.0,
"jump distance is one metre per revolution"
)
jump.set_element(PathSegmentModel.ElementType.JUMP, "2A", 0)
_check_approx(
jump.get_jump_revolutions(),
2.5,
"an Axel adds half a revolution"
)
jump.set_element(PathSegmentModel.ElementType.JUMP, "unbekannt", 0)
_check_approx(
jump.get_jump_revolutions(),
1.0,
"unknown jump codes fall back to one revolution"
)
jump.set_element(PathSegmentModel.ElementType.JUMP, "3Lz", 0)
_check(jump.has_jump_vector() == false, "new jumps start with an automatic vector")
jump.set_element_jump_vector(Vector2(0.0, 2.0))
_check(jump.has_jump_vector(), "a dragged tip stores an explicit jump vector")
_check_approx(
jump.get_jump_distance_m(),
2.0,
"the explicit vector defines the jump distance"
)
jump.set_element_jump_vector(Vector2(0.0, 40.0))
_check_approx(
jump.get_jump_distance_m(),
PathSegmentModel.ELEMENT_MAX_JUMP_DISTANCE_M,
"the jump vector is clamped to the maximum"
)
jump.set_element_jump_vector(Vector2.ZERO)
_check(not jump.has_jump_vector(), "a zero vector means automatic")
_check_approx(
jump.get_jump_distance_m(),
3.0,
"zero vector falls back to the code distance"
)
jump.set_element(PathSegmentModel.ElementType.SEQUENCE, "StSq", 0)
_check(not jump.has_jump_vector(), "a sequence drops the jump vector")
jump.set_element(PathSegmentModel.ElementType.JUMP, "3Lz", 0)
var spin: PathSegment = PathSegmentModel.new()
spin.segment_id = "seg-spin"
@ -236,6 +284,53 @@ func _test_element_markers() -> void:
)
spin.set_element_duration(8.0)
spin.set_element_revolutions(12.0)
_check_approx(
spin.get_spin_revolutions_per_second(),
1.5,
"spin rate is revolutions divided by stand time"
)
spin.set_element_revolutions(-3.0)
_check_approx(
spin.element_revolutions,
0.0,
"negative revolutions are clamped to zero"
)
spin.element_revolutions = 500.0
_check(
not spin.is_valid(),
"revolutions above the maximum are invalid"
)
spin.set_element_revolutions(20.0)
_check(spin.is_valid(), "a spin with a plausible revolution count is valid")
_check(
spin.element_rotation_direction == PathSegmentModel.RotationDirection.COUNTERCLOCKWISE,
"spins default to counterclockwise"
)
_check_approx(
spin.get_rotation_sign(),
-1.0,
"counterclockwise spins use negative screen angles"
)
_check(
PathSegmentModel.rotation_direction_name(
PathSegmentModel.RotationDirection.COUNTERCLOCKWISE
) == "linksherum",
"counterclockwise is named linksherum"
)
spin.element_rotation_direction = PathSegmentModel.RotationDirection.CLOCKWISE
_check_approx(
spin.get_rotation_sign(),
1.0,
"clockwise spins use positive screen angles"
)
_check(
PathSegmentModel.rotation_direction_name(
PathSegmentModel.RotationDirection.CLOCKWISE
) == "rechtsherum",
"clockwise is named rechtsherum"
)
spin.set_element(
PathSegmentModel.ElementType.SEQUENCE,
"123456789012345678901234567890",
@ -249,6 +344,21 @@ func _test_element_markers() -> void:
spin.get_element_caption() == spin.element_code,
"sequence caption uses the truncated code"
)
_check_approx(
spin.element_revolutions,
0.0,
"switching to a sequence drops the spin revolutions"
)
_check_approx(
spin.get_spin_revolutions_per_second(),
0.0,
"a sequence has no rotation rate"
)
_check(
spin.element_rotation_direction
== PathSegmentModel.RotationDirection.COUNTERCLOCKWISE,
"a sequence drops the spin direction"
)
spin.set_element(PathSegmentModel.ElementType.NONE, "rest", 3)
_check(
@ -467,6 +577,112 @@ func _test_section_aggregation() -> void:
_check_approx(section.get_length_m(), 10.0, "markers keep the section length")
func _test_element_groups() -> void:
var section: RoutineSection = RoutineSectionModel.new()
section.section_id = "section-steps"
section.sequence_order = 0
var first := _make_segment(
"seg-steps-1",
3.0,
Vector2(-5.0, 0.0),
Vector2(0.0, 0.0)
)
var second := _make_segment(
"seg-steps-2",
2.0,
Vector2(0.0, 0.0),
Vector2(5.0, 0.0)
)
var third := _make_segment(
"seg-steps-3",
1.0,
Vector2(5.0, 0.0),
Vector2(5.0, 5.0)
)
first.element_group_id = "el-001"
second.element_group_id = "el-001"
third.element_group_id = "el-001"
first.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 2)
section.segments = [first, second, third]
var elements := section.get_elements()
_check(elements.size() == 1, "a sequence group resolves to one element")
if not elements.is_empty():
var element: ResolvedElement = elements[0]
_check(element.get_lead() == first, "the tagged segment is the lead")
_check(element.segments.size() == 3, "all member segments are resolved")
_check(element.get_type() == PathSegment.ElementType.SEQUENCE, "type is resolved")
_check(element.get_code() == "StSq", "code is read from the lead")
_check(element.get_level() == 2, "level is read from the lead")
_check_approx(
element.get_duration_seconds(),
6.0,
"group duration sums all member segments"
)
var member_element := section.get_element_for_segment("seg-steps-2")
_check(
member_element != null
and member_element.element_id == element.element_id,
"a member segment resolves to its group"
)
_check(
section.get_element_group_segments("el-001").size() == 3,
"group segments can be looked up by id"
)
_check(section.is_valid(), "a well-formed sequence group is valid")
# Members must stay adjacent and the group needs exactly one lead.
var split := section.duplicate(true) as RoutineSection
split.segments[1].element_group_id = ""
var split_errors := split.validate()
_check(
_contains_error(split_errors, "split across non-adjacent"),
"non-adjacent group members are rejected"
)
var two_leads := section.duplicate(true) as RoutineSection
two_leads.segments[1].set_element(
PathSegment.ElementType.SEQUENCE,
"StSq",
2
)
_check(
_contains_error(two_leads.validate(), "exactly one lead"),
"a group may have only one lead segment"
)
var wrong_type := section.duplicate(true) as RoutineSection
wrong_type.segments[0].set_element(
PathSegment.ElementType.SPIN,
"CCoSp",
0
)
_check(
_contains_error(wrong_type.validate(), "only supported for sequence ranges"),
"only sequence ranges may span multiple segments"
)
var no_lead: RoutineSection = RoutineSectionModel.new()
no_lead.section_id = "section-steps"
no_lead.sequence_order = 0
var orphan := _make_segment(
"seg-orphan",
1.0,
Vector2(0.0, 0.0),
Vector2(1.0, 0.0)
)
orphan.element_group_id = "el-orphan"
no_lead.segments = [orphan]
_check(
_contains_error(no_lead.validate(), "needs exactly one lead"),
"a group without a lead is rejected"
)
_check(
no_lead.get_elements().is_empty(),
"an orphan group resolves to no element"
)
func _test_routine_validation() -> void:
var routine: Routine = _make_routine()

View file

@ -6,6 +6,8 @@ extends SceneTree
## godot --headless --path rinkplanner --script res://tests/run_playback_tests.gd
const WhiteboardScene := preload("res://scenes/whiteboard/whiteboard.tscn")
const PLAY_ICON := preload("res://assets/icons/playback/play.svg")
const PAUSE_ICON := preload("res://assets/icons/playback/pause.svg")
var _assertions: int = 0
var _failures: PackedStringArray = PackedStringArray()
@ -204,13 +206,13 @@ func _run() -> void:
controller.play()
_check(controller.is_playing(), "play starts playback")
_check(controller.play_button.text == "Pause", "play button switches to pause")
_check(controller.play_button.icon == PAUSE_ICON, "play button switches to pause")
controller.advance_playback(0.5)
_check_approx(controller.get_playback_time(), 5.5, "playback advances by delta")
controller.advance_playback(1.0)
_check(not controller.is_playing(), "playback stops at the end")
_check_approx(controller.get_playback_time(), 6.0, "playback ends at the total duration")
_check(controller.play_button.text == "Start", "play button switches back after the end")
_check(controller.play_button.icon == PLAY_ICON, "play button switches back after the end")
controller.play()
_check_approx(
@ -270,7 +272,7 @@ func _run() -> void:
)
_check_approx(
spin_marker.element_duration_seconds,
8.0,
4.0,
"spin marker gets a default stand time"
)
var zero_marker := controller.add_element_marker(
@ -287,7 +289,7 @@ func _run() -> void:
controller._update_status()
_check_approx(
controller.get_playback_duration(),
14.7,
10.7,
"timeline duration includes the element stand times"
)
@ -298,11 +300,47 @@ func _run() -> void:
"timeline stops at the jump marker"
)
var jump_heading := controller.get_playback_heading()
var jump_takeoff := controller.get_playback_position()
controller.seek_playback(jump_start + 0.35)
_check(
jump_heading.dot(controller.get_playback_heading()) > 0.99,
"jump marker keeps the arrival heading"
jump_heading.dot(controller.get_playback_heading()) < -0.9,
"jump marker turns half of its air revolutions"
)
_check(
controller.rink_canvas.get_playback_marker_scale() > 1.5,
"jump marker grows while the skater is in the air"
)
var jump_travel := controller.get_playback_position() - jump_takeoff
_check_approx(
jump_travel.length(),
1.5,
"jump marker travels half of the jump distance mid-air"
)
_check(
jump_travel.normalized().dot(jump_heading) > 0.99,
"jump marker follows the jump vector"
)
controller.seek_playback(jump_start + 0.699)
_check(
jump_heading.dot(controller.get_playback_heading()) > 0.99,
"the jump ends in the arrival heading after whole revolutions"
)
jump_marker.set_element_jump_vector(Vector2(0.0, 2.0))
controller.seek_playback(jump_start)
var explicit_takeoff := controller.get_playback_position()
controller.seek_playback(jump_start + 0.35)
var explicit_travel := controller.get_playback_position() - explicit_takeoff
_check_approx(
explicit_travel.length(),
1.0,
"an explicit jump vector defines the travelled distance"
)
_check(
explicit_travel.normalized().dot(Vector2(0.0, 1.0)) > 0.99,
"the jump follows the dragged vector direction"
)
jump_marker.set_element_jump_vector(Vector2.ZERO)
var spin_start := jump_start + 0.7
controller.seek_playback(spin_start)
@ -311,11 +349,51 @@ func _run() -> void:
"timeline stops at the spin marker"
)
var spin_arrival := controller.get_playback_heading()
controller.seek_playback(spin_start + 1.0 / 3.0)
var spin_turn_seconds := 1.0 / WhiteboardController.SPIN_REVOLUTIONS_PER_SECOND
controller.seek_playback(spin_start + spin_turn_seconds * 0.5)
_check(
spin_arrival.dot(controller.get_playback_heading()) < -0.9,
"spin marker rotates the playback dot in place"
)
controller.seek_playback(spin_start + spin_turn_seconds)
_check(
spin_arrival.dot(controller.get_playback_heading()) > 0.99,
"one spin revolution returns to the arrival heading"
)
# Direction: counterclockwise turns left (negative screen angle), clockwise
# turns right.
var quarter_turn := spin_turn_seconds * 0.25
spin_marker.element_rotation_direction = (
PathSegment.RotationDirection.COUNTERCLOCKWISE
)
controller.seek_playback(spin_start)
var ccw_arrival := controller.get_playback_heading()
controller.seek_playback(spin_start + quarter_turn)
_check(
ccw_arrival.cross(controller.get_playback_heading()) < -0.5,
"counterclockwise spin turns left"
)
spin_marker.element_rotation_direction = PathSegment.RotationDirection.CLOCKWISE
controller.seek_playback(spin_start)
var cw_arrival := controller.get_playback_heading()
controller.seek_playback(spin_start + quarter_turn)
_check(
cw_arrival.cross(controller.get_playback_heading()) > 0.5,
"clockwise spin turns right"
)
# The planned revolution count drives the rate: 4 revolutions in 8 s are
# 0.5 rev/s, so a half turn takes one second.
spin_marker.set_element_revolutions(2.0)
controller.seek_playback(spin_start)
var slow_spin_arrival := controller.get_playback_heading()
controller.seek_playback(spin_start + 1.0)
_check(
slow_spin_arrival.dot(controller.get_playback_heading()) < -0.9,
"planned revolutions scale the spin rotation in playback"
)
spin_marker.set_element_revolutions(10.0)
# Timeline labels: element labels are drawn read-only and a click on the
# lane creates an editable custom label at that time.

View file

@ -53,6 +53,49 @@ func _run() -> void:
var drawn := section.segments[section.segments.size() - 1]
_check(drawn.get_length_m() > 9.5, "touch-drawn segment has the drag length")
# Freehand touch drawing keeps multiple sampled points.
controller.set_tool(WhiteboardController.Tool.FREELINE)
var freehand_count_before := section.segments.size()
var freehand_points: Array[Vector2] = [
Vector2(10.0, -8.0),
Vector2(14.0, -6.0),
Vector2(18.0, -9.0),
Vector2(22.0, -7.0),
]
var previous := view.model_to_screen(freehand_points[0])
_touch(canvas, 0, previous, true)
for index: int in range(1, freehand_points.size()):
var current := view.model_to_screen(freehand_points[index])
_drag(canvas, 0, current, current - previous)
previous = current
_touch(canvas, 0, previous, false)
_check(
section.segments.size() == freehand_count_before + 1,
"touch freehand creates one segment"
)
var freehand := section.segments[section.segments.size() - 1]
_check(freehand.is_freehand(), "touch freehand keeps its template")
_check(
freehand.curve.point_count >= freehand_points.size(),
"touch freehand keeps multiple sampled points"
)
controller.set_tool(WhiteboardController.Tool.SELECT)
controller.select_segment(freehand.segment_id)
var interior_index := 2
var interior_before := freehand.curve.get_point_position(interior_index)
var interior_target := interior_before + Vector2(0.0, 1.5)
var interior_screen := view.model_to_screen(interior_before)
var target_screen := view.model_to_screen(interior_target)
_touch(canvas, 0, interior_screen, true)
_drag(canvas, 0, target_screen, target_screen - interior_screen)
_touch(canvas, 0, target_screen, false)
_check_vec(
freehand.curve.get_point_position(interior_index),
interior_target,
"touch drags a freehand interior point"
)
controller.set_tool(WhiteboardController.Tool.LINE)
# Chrome emits a synthetic mouse press immediately before the touch press.
# The touch press must cancel that stray mouse segment.
canvas._ignore_mouse_until_msec = 0
@ -93,9 +136,11 @@ func _run() -> void:
section.segments.size() == count_before_marker + 1,
"one tap places an element marker"
)
var placed_marker := section.segments[section.segments.size() - 1]
# The marker is inserted along the path, not necessarily appended, so the
# newly selected segment is the marker that was just placed.
var placed_marker := controller.get_selected_segment()
_check(
placed_marker.is_element_marker(),
placed_marker != null and placed_marker.is_element_marker(),
"tapped marker is a zero-length element"
)
_check(

View file

@ -26,6 +26,7 @@ func _init() -> void:
_validator = RoutineValidatorScript.new(_catalog, _rules)
_test_clean_routine()
_test_sequence_group_counts_once()
_test_unknown_code()
_test_type_mismatch()
_test_unavailable_level()
@ -107,6 +108,58 @@ func _test_clean_routine() -> void:
)
func _test_sequence_group_counts_once() -> void:
var routine := _make_routine()
var section := routine.sections[0]
var group_id := "el-001"
for index: int in range(3):
var segment: PathSegment = PathSegmentModel.new()
segment.segment_id = "seq-%d" % index
var curve := Curve2D.new()
curve.add_point(Vector2(0.0, float(index) * 2.0))
curve.add_point(Vector2(5.0, float(index) * 2.0))
segment.curve = curve
segment.set_speed_mps(4.3)
segment.element_group_id = group_id
if index == 0:
segment.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 0)
section.segments.append(segment)
var elements := section.get_elements()
_check(elements.size() == 1, "a sequence group resolves to one element")
if not elements.is_empty():
_check(
elements[0].segments.size() == 3,
"the resolved sequence keeps all member segments"
)
_check(
elements[0].get_lead() == section.segments[0],
"the tagged segment is the sequence lead"
)
_check_approx(
elements[0].get_duration_seconds(),
section.segments[0].duration_seconds
+ section.segments[1].duration_seconds
+ section.segments[2].duration_seconds,
"the element duration sums all group segments"
)
var report := _validator.validate_report(routine)
_check(report.element_count == 1, "a sequence group counts as one element")
_check(report.scored_elements == 1, "the sequence is scored once")
_check(report.element_values.size() == 1, "the report keeps one value entry")
_check(report.get_check("code").passed == 1, "the sequence code is checked once")
_check_approx(
report.base_value_total,
_catalog.get_base_value(
"StSq",
0,
PathSegment.ElementType.SEQUENCE
),
"the sequence base value is counted once"
)
func _test_unknown_code() -> void:
var report := _report_one(
PathSegment.ElementType.SPIN,

View file

@ -30,6 +30,11 @@ func _run() -> void:
_finish()
return
_check(
controller.get_tool() == WhiteboardController.Tool.SELECT,
"the select tool is active at startup"
)
var routine := controller.get_routine()
var section := controller.get_active_section()
_check(routine != null, "controller owns a routine")
@ -133,6 +138,7 @@ func _run() -> void:
var view := canvas.get_view_transform()
var segment_count_before := section.segments.size()
controller.set_tool(WhiteboardController.Tool.LINE)
_mouse_button(canvas, view.model_to_screen(Vector2(-15.0, 5.0)), true)
_mouse_motion(canvas, view.model_to_screen(Vector2(-5.0, 5.0)))
_mouse_button(canvas, view.model_to_screen(Vector2(-5.0, 5.0)), false)
@ -224,6 +230,76 @@ func _run() -> void:
controller.get_tool() == WhiteboardController.Tool.ARC_LEFT,
"tool can be selected programmatically"
)
# The tool palette is a row of toggle buttons: clicking one switches the
# tool and exactly one icon stays highlighted.
var tool_buttons: Array[Button] = [
controller.get_node("%SelectToolButton"),
controller.get_node("%LineToolButton"),
controller.get_node("%ArcLeftToolButton"),
controller.get_node("%ArcRightToolButton"),
controller.get_node("%FreeLineToolButton"),
controller.get_node("%JumpToolButton"),
controller.get_node("%SpinToolButton"),
controller.get_node("%SequenceToolButton"),
]
var arc_right_button: Button = controller.get_node("%ArcRightToolButton")
arc_right_button.pressed.emit()
_check(
controller.get_tool() == WhiteboardController.Tool.ARC_RIGHT,
"clicking a tool icon selects that tool"
)
controller.set_tool(WhiteboardController.Tool.ARC_LEFT)
var highlighted := 0
for button: Button in tool_buttons:
if button.button_pressed:
highlighted += 1
_check(
highlighted == 1
and (controller.get_node("%ArcLeftToolButton") as Button).button_pressed,
"exactly the active tool icon is highlighted"
)
# Jump and spin pick a point-marker type and share the element tool.
var element_buttons := [
["%JumpToolButton", PathSegment.ElementType.JUMP],
["%SpinToolButton", PathSegment.ElementType.SPIN],
]
for entry: Array in element_buttons:
var button: Button = controller.get_node(entry[0])
button.pressed.emit()
_check(
controller.get_tool() == WhiteboardController.Tool.ELEMENT
and controller.get_element_type() == entry[1],
"%s picks its element type" % entry[0]
)
var pressed_count := 0
for candidate: Array in element_buttons:
if (controller.get_node(candidate[0]) as Button).button_pressed:
pressed_count += 1
_check(
pressed_count == 1 and button.button_pressed,
"%s is the only highlighted element icon" % entry[0]
)
# The sequence icon starts drawing mode instead of placing a point marker.
controller.set_tool(WhiteboardController.Tool.ARC_LEFT)
var sequence_button: Button = controller.get_node("%SequenceToolButton")
sequence_button.pressed.emit()
_check(
controller.is_sequence_mode()
and controller.get_element_type() == PathSegment.ElementType.SEQUENCE,
"the sequence icon starts sequence drawing mode"
)
_check(
sequence_button.button_pressed
and (controller.get_node("%ArcLeftToolButton") as Button).button_pressed,
"sequence mode keeps the current path tool active"
)
sequence_button.pressed.emit()
_check(not controller.is_sequence_mode(), "the sequence icon finishes sequence mode")
controller.set_element_type(PathSegment.ElementType.JUMP)
controller.set_tool(WhiteboardController.Tool.ARC_LEFT)
_mouse_button(canvas, view.model_to_screen(Vector2(-15.0, 5.0)), true)
_mouse_motion(canvas, view.model_to_screen(Vector2(-5.0, 5.0)))
_mouse_button(canvas, view.model_to_screen(Vector2(-5.0, 5.0)), false)
@ -241,6 +317,97 @@ func _run() -> void:
"dragged left arc bulges below its chord"
)
# Freehand tool: the drag path is sampled into a multi-point curve.
var freehand_count_before := section.segments.size()
controller.set_tool(WhiteboardController.Tool.FREELINE)
var freehand_path: Array[Vector2] = [
Vector2(-26.0, 6.0),
Vector2(-22.0, 8.0),
Vector2(-18.0, 6.0),
Vector2(-14.0, 8.0),
Vector2(-12.0, 6.0),
]
_mouse_button(
canvas,
view.model_to_screen(freehand_path[0]),
true
)
for index: int in range(1, freehand_path.size()):
_mouse_motion(canvas, view.model_to_screen(freehand_path[index]))
_mouse_button(
canvas,
view.model_to_screen(freehand_path[freehand_path.size() - 1]),
false
)
_check(
section.segments.size() == freehand_count_before + 1,
"freehand mode creates a segment"
)
var freehand := section.segments[section.segments.size() - 1]
_check(freehand.is_freehand(), "freehand path keeps its template")
_check(
freehand.curve.point_count == freehand_path.size(),
"freehand path keeps the sampled points"
)
_check(
freehand.get_length_m() > 10.0,
"freehand length follows the drawn path"
)
_check(
freehand.duration_seconds > 0.0,
"freehand duration is derived from the path length"
)
_check(not freehand.is_marker(), "freehand is a path segment, not a marker")
# Endpoint handles reshape the curve without collapsing it to a line.
controller.set_tool(WhiteboardController.Tool.SELECT)
controller.select_segment(freehand.segment_id)
var freehand_start := freehand.curve.get_point_position(0)
controller._apply_handle_drag(
freehand,
RinkCanvas.Handle.START,
freehand_start + Vector2(1.0, 0.5)
)
_check(
freehand.curve.point_count == freehand_path.size(),
"freehand handle drag keeps all sampled points"
)
_check_vec(
freehand.curve.get_point_position(0),
freehand_start + Vector2(1.0, 0.5),
"freehand start handle moves the first point"
)
# Interior freehand points get their own small handles.
var interior_index := 2
var interior_before := freehand.curve.get_point_position(interior_index)
var interior_target := interior_before + Vector2(0.0, 1.5)
_mouse_button(
canvas,
view.model_to_screen(interior_before),
true
)
_mouse_motion(canvas, view.model_to_screen(interior_target))
_mouse_button(
canvas,
view.model_to_screen(interior_target),
false
)
_check(
freehand.curve.point_count == freehand_path.size(),
"freehand point drag keeps the sampled points"
)
_check_vec(
freehand.curve.get_point_position(interior_index),
interior_target,
"freehand interior point can be dragged"
)
_check_vec(
freehand.curve.get_point_position(0),
freehand_start + Vector2(1.0, 0.5),
"dragging one freehand point leaves the others alone"
)
# Selection and handle editing.
controller.set_tool(WhiteboardController.Tool.SELECT)
var apex_before := arc_left.curve.sample_baked(arc_left.get_length_m() * 0.5)
@ -621,6 +788,7 @@ func _run() -> void:
# Element markers (D3): a jump point/spin centre is a zero-length segment.
controller.set_tool(WhiteboardController.Tool.ELEMENT)
controller.set_element_type(PathSegment.ElementType.JUMP)
_check(
canvas.is_marker_placement_enabled(),
"element tool enables marker placement"
@ -661,6 +829,15 @@ func _run() -> void:
controller.status_label.text.contains("Sprung"),
"status bar names the placed element"
)
_check_approx(
jump.get_jump_distance_m(),
1.0,
"a jump without a code gets a one metre vector"
)
_check(
controller.status_label.text.contains("1,0 m"),
"status bar shows the jump distance"
)
_check_approx(
controller.get_playback_duration(),
controller.get_routine().get_duration_seconds(),
@ -672,6 +849,39 @@ func _run() -> void:
"routine duration includes the jump air time"
)
controller.element_button.pressed.emit()
_check(
controller.element_rotation_box.visible,
"jump dialog shows the rotation direction"
)
_check(
not controller.element_revolutions_box.visible,
"jump dialog hides the spin revolution field"
)
controller.element_dialog.hide()
# Dragging the arrow tip stores an explicit jump vector (direction and
# distance) instead of the code-derived default.
controller._apply_handle_drag(
jump,
RinkCanvas.Handle.JUMP_TIP,
jump_point + Vector2(0.0, 2.0)
)
_check(
jump.element_jump_vector.is_equal_approx(Vector2(0.0, 2.0)),
"jump tip drag stores the vector"
)
_check_approx(
jump.get_jump_distance_m(),
2.0,
"jump tip drag updates the distance"
)
_check(
canvas._handle_at(view.model_to_screen(jump_point + Vector2(0.0, 2.0)))
== RinkCanvas.Handle.JUMP_TIP,
"the arrow tip is a drag handle"
)
# A tap on the selected marker handle must not record an undo entry:
# undo has to remove the marker itself.
var jump_id := jump.segment_id
@ -707,9 +917,24 @@ func _run() -> void:
)
_check_approx(
spin.element_duration_seconds,
8.0,
4.0,
"spin gets the default stand time"
)
_check_approx(
spin.element_revolutions,
10.0,
"spin starts with the ISU combination minimum"
)
_check_approx(
spin.get_spin_revolutions_per_second(),
2.5,
"default spin rotates with 2.5 revolutions per second"
)
_check(
spin.element_rotation_direction
== PathSegment.RotationDirection.COUNTERCLOCKWISE,
"new spins rotate counterclockwise by default"
)
_check(
controller.set_selected_element(
@ -729,7 +954,7 @@ func _run() -> void:
)
_check_approx(
spin.element_duration_seconds,
8.0,
4.0,
"editing code keeps the stand time"
)
_check(controller.undo(), "element edit can be undone")
@ -772,6 +997,25 @@ func _run() -> void:
controller.select_segment(spin.segment_id)
controller.element_button.pressed.emit()
_check(controller.element_dialog.visible, "element button opens the dialog")
_check(
controller.element_revolutions_box.visible,
"spin dialog shows the revolution field"
)
_check(
controller.element_rotation_box.visible,
"spin dialog shows the rotation direction"
)
_check(
controller.element_rotation_option.get_item_id(
controller.element_rotation_option.selected
) == PathSegment.RotationDirection.COUNTERCLOCKWISE,
"spin dialog defaults to counterclockwise"
)
_check_approx(
controller.element_revolutions_spin.value,
10.0,
"spin dialog starts with the default revolution count"
)
_check(
controller.element_code_edit.text == "CCoSp",
"element dialog is prefilled with the normalized code"
@ -903,6 +1147,15 @@ func _run() -> void:
)
controller.element_duration_spin.value = 6.5
controller.element_revolutions_spin.value = 12.0
var clockwise_index := controller.element_rotation_option.get_item_index(
PathSegment.RotationDirection.CLOCKWISE
)
controller.element_rotation_option.select(clockwise_index)
_check(
controller.element_revolutions_label.text.contains("1,8 U/s"),
"dialog shows the rate derived from revolutions and stand time"
)
controller.element_dialog.confirmed.emit()
_check(
controller.get_selected_element_caption() == "CCoSp L3",
@ -917,6 +1170,21 @@ func _run() -> void:
6.5,
"element dialog applies the stand time"
)
_check_approx(
controller.get_selected_segment().element_revolutions,
12.0,
"element dialog applies the revolution count"
)
_check_approx(
controller.get_selected_segment().get_spin_revolutions_per_second(),
12.0 / 6.5,
"the spin rate follows revolutions per stand time"
)
_check(
controller.get_selected_segment().element_rotation_direction
== PathSegment.RotationDirection.CLOCKWISE,
"element dialog applies the rotation direction"
)
_check(controller.undo(), "element dialog change can be undone")
spin = controller.get_active_section().get_segment_by_id(spin.segment_id)
@ -924,6 +1192,16 @@ func _run() -> void:
spin != null and spin.element_features.size() == 2 and spin.element_level == 2,
"undo restores features and the derived level"
)
_check_approx(
spin.element_revolutions,
10.0,
"undo restores the previous revolution count"
)
_check(
spin.element_rotation_direction
== PathSegment.RotationDirection.COUNTERCLOCKWISE,
"undo restores the previous rotation direction"
)
controller.select_segment(spin.segment_id)
_check(controller.redo(), "element dialog change can be redone")
spin = controller.get_active_section().get_segment_by_id(spin.segment_id)
@ -1619,6 +1897,594 @@ func _run() -> void:
if FileAccess.file_exists(path):
DirAccess.remove_absolute(ProjectSettings.globalize_path(path))
# Element markers take their chronological position from the drawn path:
# taps at the start or between segments insert instead of appending.
controller.new_routine()
var insert_section := controller.get_active_section()
var first_path := controller.add_segment(
Vector2(-20.0, 0.0),
Vector2(-10.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
var second_path := controller.add_segment(
Vector2(-10.0, 0.0),
Vector2(0.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
var start_marker := controller.add_element_marker(
Vector2(-19.5, 0.0),
PathSegment.ElementType.JUMP,
"1T",
0
)
_check(
insert_section.segments.find(start_marker) == 0,
"a tap at the path start inserts the marker at the beginning"
)
var middle_marker := controller.add_element_marker(
Vector2(-10.0, 0.0),
PathSegment.ElementType.SPIN,
"CCoSp",
0
)
_check(
insert_section.segments.find(middle_marker) == 2,
"a tap between two segments inserts the marker there"
)
_check(
insert_section.segments.find(first_path)
< insert_section.segments.find(middle_marker)
and insert_section.segments.find(middle_marker)
< insert_section.segments.find(second_path),
"the inserted marker keeps the path order"
)
var end_marker := controller.add_element_marker(
Vector2(0.0, 0.0),
PathSegment.ElementType.SEQUENCE,
"StSq",
0
)
_check(
insert_section.segments.find(end_marker)
== insert_section.segments.size() - 1,
"a tap behind the last segment appends the marker"
)
# Sequence drawing mode: consecutive drags become one sequence range.
controller.new_routine()
controller.set_tool(WhiteboardController.Tool.LINE)
var sequence_view := canvas.get_view_transform()
var range_sequence_button: Button = controller.get_node("%SequenceToolButton")
range_sequence_button.pressed.emit()
_check(controller.is_sequence_mode(), "sequence drawing mode can be started")
var sequence_section := controller.get_active_section()
controller.set_tool(WhiteboardController.Tool.LINE)
_mouse_button(canvas, sequence_view.model_to_screen(Vector2(-15.0, 0.0)), true)
_mouse_motion(canvas, sequence_view.model_to_screen(Vector2(-5.0, 0.0)))
_mouse_button(canvas, sequence_view.model_to_screen(Vector2(-5.0, 0.0)), false)
_mouse_button(canvas, sequence_view.model_to_screen(Vector2(-5.0, 0.0)), true)
_mouse_motion(canvas, sequence_view.model_to_screen(Vector2(5.0, 0.0)))
_mouse_button(canvas, sequence_view.model_to_screen(Vector2(5.0, 0.0)), false)
var sequence_elements := sequence_section.get_elements()
_check(
sequence_elements.size() == 1,
"two drawn segments resolve to one sequence element"
)
if sequence_elements.size() == 1:
var sequence_element: ResolvedElement = sequence_elements[0]
_check(
sequence_element.segments.size() == 2,
"the sequence group contains both drawn segments"
)
_check(
sequence_element.get_lead() == sequence_section.segments[0],
"the first drawn segment is the sequence lead"
)
_check(
sequence_element.get_code() == "StSq",
"a new sequence starts with the StSq code"
)
_check(
sequence_element.is_sequence_range(),
"the drawn group is a sequence range, not a point marker"
)
_check(
controller.timeline_label_lane.get_element_label_count() == 1,
"the sequence group shows one timeline label"
)
# Finish the group, then continue it from a member at the section tail.
range_sequence_button.pressed.emit()
_check(not controller.is_sequence_mode(), "the sequence button finishes the group")
var tail_member := sequence_section.segments[1]
controller.select_segment(tail_member.segment_id)
range_sequence_button.pressed.emit()
_check(
controller.is_sequence_mode(),
"sequence mode continues a group that ends at the section tail"
)
controller.set_tool(WhiteboardController.Tool.LINE)
_mouse_button(canvas, sequence_view.model_to_screen(Vector2(-15.0, 5.0)), true)
_mouse_motion(canvas, sequence_view.model_to_screen(Vector2(-5.0, 5.0)))
_mouse_button(canvas, sequence_view.model_to_screen(Vector2(-5.0, 5.0)), false)
_check(
sequence_section.get_elements().size() == 1
and sequence_section.get_elements()[0].segments.size() == 3,
"a drawn segment continues the selected sequence group"
)
range_sequence_button.pressed.emit()
# Leaving sequence mode must not pull later path segments into the group.
controller.set_tool(WhiteboardController.Tool.LINE)
_mouse_button(canvas, sequence_view.model_to_screen(Vector2(-15.0, 10.0)), true)
_mouse_motion(canvas, sequence_view.model_to_screen(Vector2(-5.0, 10.0)))
_mouse_button(canvas, sequence_view.model_to_screen(Vector2(-5.0, 10.0)), false)
_check(
sequence_section.segments.size() == 4,
"a segment drawn after the group is added to the section"
)
_check(
sequence_section.get_elements().size() == 1
and sequence_section.get_elements()[0].segments.size() == 3,
"a segment after sequence mode stays outside the group"
)
# Selecting a member shows and edits the lead element.
var sequence_member := sequence_section.segments[1]
controller.select_segment(sequence_member.segment_id)
_check(
controller.get_selected_element() != null
and controller.get_selected_element().segments.size() == 3,
"selecting a member resolves the whole sequence"
)
controller.element_button.pressed.emit()
_check(controller.element_dialog.visible, "the element dialog opens from a member")
_check(
controller.element_dialog_type_option.get_item_id(
controller.element_dialog_type_option.selected
) == PathSegment.ElementType.SEQUENCE,
"the dialog shows the sequence type of the group"
)
controller.element_dialog.hide()
# Deleting the lead promotes the next member and keeps the element data.
var old_lead := sequence_section.get_elements()[0].get_lead()
controller.select_segment(old_lead.segment_id)
_check(controller.delete_selected_segment(), "the sequence lead can be deleted")
var promoted := sequence_section.get_elements()
_check(
promoted.size() == 1 and promoted[0].get_lead() != old_lead,
"deleting the lead promotes another member"
)
if promoted.size() == 1:
_check(
promoted[0].get_code() == "StSq",
"the promoted member keeps the sequence code"
)
# Clearing the element dissolves the group but keeps the path segments.
controller.select_segment(promoted[0].segments[0].segment_id)
_check(
controller.set_selected_element(PathSegment.ElementType.NONE, "", 0),
"the element can be cleared from a group"
)
_check(
promoted[0].segments[0].element_group_id.is_empty(),
"clearing the element removes the group id"
)
_check(
sequence_section.get_elements().is_empty(),
"a cleared group resolves to no elements"
)
# A marker placed near a group must not split the group in two.
controller.new_routine()
var group_section := controller.get_active_section()
var group_a := controller.add_segment(
Vector2(-10.0, 0.0),
Vector2(0.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
var group_b := controller.add_segment(
Vector2(0.0, 0.0),
Vector2(10.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
_check(
controller.group_segments_as_sequence(
PackedStringArray([group_a.segment_id, group_b.segment_id]),
"StSq",
0
) != null,
"existing segments can be grouped as a sequence"
)
var group_marker := controller.add_element_marker(
Vector2(0.0, 0.0),
PathSegment.ElementType.JUMP,
"1T",
0
)
_check(
group_section.get_elements().size() == 2
and group_section.get_elements()[0].segments.size() == 2,
"a marker near the group does not split the sequence"
)
_check(
group_section.segments.find(group_marker) > group_section.segments.find(group_b),
"the marker is inserted behind the group"
)
_check(group_section.is_valid(), "the section stays valid with marker and group")
# A legacy single-segment sequence becomes a group when it is continued.
controller.new_routine()
var legacy_section := controller.get_active_section()
var legacy_range := controller.add_segment(
Vector2(-10.0, 0.0),
Vector2(0.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
controller.select_segment(legacy_range.segment_id)
_check(
controller.set_selected_element(
PathSegment.ElementType.SEQUENCE,
"StSq",
0
),
"a single segment can be tagged as a sequence range"
)
_check(
legacy_range.element_group_id.is_empty(),
"a single tagged segment needs no group id yet"
)
var legacy_button: Button = controller.get_node("%SequenceToolButton")
legacy_button.pressed.emit()
controller.set_tool(WhiteboardController.Tool.LINE)
var legacy_view := canvas.get_view_transform()
_mouse_button(canvas, legacy_view.model_to_screen(Vector2(0.0, 0.0)), true)
_mouse_motion(canvas, legacy_view.model_to_screen(Vector2(10.0, 0.0)))
_mouse_button(canvas, legacy_view.model_to_screen(Vector2(10.0, 0.0)), false)
var legacy_elements := legacy_section.get_elements()
_check(
legacy_elements.size() == 1 and legacy_elements[0].segments.size() == 2,
"drawing after a legacy range turns it into a group"
)
if legacy_elements.size() == 1:
_check(
not legacy_elements[0].get_group_id().is_empty(),
"the continued legacy range gets a group id"
)
_check(
legacy_elements[0].segments[0].element_group_id
== legacy_elements[0].segments[1].element_group_id,
"both continued segments share the group id"
)
legacy_button.pressed.emit()
# Undo removes one drawn part at a time and keeps the group consistent.
controller.new_routine()
controller.set_tool(WhiteboardController.Tool.LINE)
var undo_sequence_button: Button = controller.get_node("%SequenceToolButton")
undo_sequence_button.pressed.emit()
controller.set_tool(WhiteboardController.Tool.LINE)
var undo_view := canvas.get_view_transform()
_mouse_button(canvas, undo_view.model_to_screen(Vector2(-10.0, 0.0)), true)
_mouse_motion(canvas, undo_view.model_to_screen(Vector2(0.0, 0.0)))
_mouse_button(canvas, undo_view.model_to_screen(Vector2(0.0, 0.0)), false)
_mouse_button(canvas, undo_view.model_to_screen(Vector2(0.0, 0.0)), true)
_mouse_motion(canvas, undo_view.model_to_screen(Vector2(10.0, 0.0)))
_mouse_button(canvas, undo_view.model_to_screen(Vector2(10.0, 0.0)), false)
var undo_section := controller.get_active_section()
_check(
undo_section.get_elements().size() == 1
and undo_section.get_elements()[0].segments.size() == 2,
"the undo fixture has one two-part sequence"
)
_check(controller.undo(), "the last sequence part can be undone")
var undone_section := controller.get_active_section()
_check(
undone_section.get_elements().size() == 1
and undone_section.get_elements()[0].segments.size() == 1,
"undo leaves a valid one-part sequence"
)
_check(controller.undo(), "the first sequence part can be undone")
undone_section = controller.get_active_section()
_check(
undone_section.get_elements().is_empty(),
"undo removes the empty sequence group"
)
# Sequence drawing mode also accepts freehand strokes.
controller.set_tool(WhiteboardController.Tool.SELECT)
var freehand_sequence_button: Button = controller.get_node("%SequenceToolButton")
freehand_sequence_button.pressed.emit()
controller.set_tool(WhiteboardController.Tool.FREELINE)
_check(
controller.is_sequence_mode(),
"sequence mode stays active when switching to freeline"
)
freehand_sequence_button.pressed.emit()
# Multi-selection groups existing segments into a sequence.
controller.new_routine()
controller.set_tool(WhiteboardController.Tool.SELECT)
var group_view := canvas.get_view_transform()
var multi_a := controller.add_segment(
Vector2(-10.0, 0.0),
Vector2(0.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
var multi_b := controller.add_segment(
Vector2(0.0, 0.0),
Vector2(10.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
var multi_c := controller.add_segment(
Vector2(10.0, 0.0),
Vector2(20.0, 0.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
controller.set_multi_select_enabled(true)
_check(
controller.multi_select_button.button_pressed,
"multi-select mode is reflected by the toggle button"
)
controller.clear_selection()
var multi_taps: Array[Vector2] = [
Vector2(-5.0, 0.0),
Vector2(5.0, 0.0),
Vector2(15.0, 0.0),
]
for point: Vector2 in multi_taps:
_mouse_button(canvas, group_view.model_to_screen(point), true)
_mouse_button(canvas, group_view.model_to_screen(point), false)
_check(
controller.get_selected_segment_ids().size() == 3,
"multi-select mode adds tapped segments to the selection"
)
_mouse_button(canvas, group_view.model_to_screen(Vector2(0.0, 12.0)), true)
_mouse_button(canvas, group_view.model_to_screen(Vector2(0.0, 12.0)), false)
_check(
controller.get_selected_segment_ids().size() == 3,
"tapping empty ice in multi-select mode keeps the selection"
)
_check(
controller.can_group_selected_as_sequence(),
"a contiguous multi-selection can become a sequence"
)
_check(
not controller.group_sequence_button.disabled,
"the group button is enabled for a valid selection"
)
_check(
controller.group_sequence_button.text.contains("3"),
"the group button shows the selection count"
)
controller.group_sequence_button.pressed.emit()
var grouped_elements := controller.get_active_section().get_elements()
_check(
grouped_elements.size() == 1
and grouped_elements[0].segments.size() == 3,
"the group button creates one sequence element"
)
_check(
not controller.is_multi_select_enabled()
and controller.get_selected_segment_ids().size() == 1,
"grouping leaves one selected lead and ends multi-select mode"
)
if grouped_elements.size() == 1:
_check(
grouped_elements[0].get_lead() == multi_a,
"grouping starts at the first selected segment"
)
_check(
controller.group_sequence_button.disabled,
"the group button disables after grouping"
)
_check(controller.undo(), "grouping can be undone")
var ungrouped_section := controller.get_active_section()
_check(
ungrouped_section.get_elements().is_empty(),
"undo restores the plain segments"
)
# A selection with a gap cannot be grouped.
controller.set_multi_select_enabled(true)
controller.clear_selection()
for point: Vector2 in [Vector2(-5.0, 0.0), Vector2(15.0, 0.0)]:
_mouse_button(canvas, group_view.model_to_screen(point), true)
_mouse_button(canvas, group_view.model_to_screen(point), false)
_check(
controller.get_selected_segment_ids().size() == 2,
"the gap fixture selects two segments"
)
_check(
not controller.can_group_selected_as_sequence()
and controller.group_sequence_button.disabled,
"a non-contiguous selection cannot be grouped"
)
controller.set_multi_select_enabled(false)
# Smoothing a jagged freehand keeps endpoints and point count, is
# undoable and is exposed through the timing-bar button.
controller.new_routine()
var smooth_section := controller.get_active_section()
var smooth_segment := PathSegment.new()
smooth_segment.segment_id = "seg-smooth"
smooth_segment.template = PathSegment.Template.FREEHAND
smooth_segment.curve = Curve2D.new()
var smooth_points: Array[Vector2] = [
Vector2(-10.0, 0.0),
Vector2(-8.0, 2.0),
Vector2(-6.0, -2.0),
Vector2(-4.0, 2.0),
Vector2(-2.0, 0.0),
]
for point: Vector2 in smooth_points:
smooth_segment.curve.add_point(point)
smooth_segment.set_speed_mps(4.3)
smooth_section.segments.append(smooth_segment)
controller.select_segment(smooth_segment.segment_id)
_check(
controller.smooth_button.visible
and not controller.smooth_button.disabled,
"the smooth button is available for a selected freehand"
)
_check(
controller.can_smooth_selected_freehand(),
"a multi-point freehand can be smoothed"
)
var before_jitter := smooth_segment.curve.get_point_position(2)
var before_length := smooth_segment.get_length_m()
controller.smooth_button.pressed.emit()
_check(
smooth_segment.curve.point_count == smooth_points.size(),
"smoothing keeps the point count"
)
_check_vec(
smooth_segment.curve.get_point_position(0),
smooth_points[0],
"smoothing keeps the first freehand point"
)
_check_vec(
smooth_segment.curve.get_point_position(smooth_points.size() - 1),
smooth_points[smooth_points.size() - 1],
"smoothing keeps the last freehand point"
)
_check_vec(
smooth_segment.curve.get_point_position(2),
Vector2(-6.0, 0.25),
"smoothing moves the interior point between its neighbours"
)
_check(
absf(smooth_segment.get_length_m() - before_length) > 0.01,
"smoothing updates the freehand length"
)
_check(controller.undo(), "smoothing can be undone")
var restored := controller.get_active_section().get_segment_by_id(
"seg-smooth"
)
_check(restored != null, "the smoothed freehand survives undo")
if restored != null:
_check_vec(
restored.curve.get_point_position(2),
before_jitter,
"undo restores the original freehand points"
)
# Freehand strokes are simplified automatically at the end of the drag.
controller.new_routine()
controller.set_tool(WhiteboardController.Tool.FREELINE)
var simplify_view := canvas.get_view_transform()
var dense_points: Array[Vector2] = []
for index: int in range(24):
dense_points.append(
Vector2(-20.0 + float(index), 0.02 * float(index % 2))
)
_mouse_button(
canvas,
simplify_view.model_to_screen(dense_points[0]),
true
)
for index: int in range(1, dense_points.size()):
_mouse_motion(
canvas,
simplify_view.model_to_screen(dense_points[index])
)
_mouse_button(
canvas,
simplify_view.model_to_screen(dense_points[dense_points.size() - 1]),
false
)
var dense_section := controller.get_active_section()
var dense_freehand := dense_section.segments[
dense_section.segments.size() - 1
]
_check(
dense_freehand.curve.point_count < dense_points.size(),
"freehand drawing simplifies dense points automatically"
)
_check_vec(
dense_freehand.curve.get_point_position(0),
dense_points[0],
"automatic simplification keeps the start point"
)
_check_vec(
dense_freehand.curve.get_point_position(
dense_freehand.curve.point_count - 1
),
dense_points[dense_points.size() - 1],
"automatic simplification keeps the end point"
)
_check(
dense_freehand.duration_seconds > 0.0,
"automatic simplification keeps a valid duration"
)
# The manual button reduces an existing freehand and is undoable.
controller.new_routine()
var simplify_section := controller.get_active_section()
var simplify_segment := PathSegment.new()
simplify_segment.segment_id = "seg-simplify"
simplify_segment.template = PathSegment.Template.FREEHAND
simplify_segment.curve = Curve2D.new()
var simplify_points: Array[Vector2] = []
for index: int in range(30):
var point := Vector2(
-18.0 + float(index),
0.02 * float(index % 2)
)
simplify_points.append(point)
simplify_segment.curve.add_point(point)
simplify_segment.set_speed_mps(4.3)
simplify_section.segments.append(simplify_segment)
controller.select_segment(simplify_segment.segment_id)
_check(
controller.simplify_button.visible
and not controller.simplify_button.disabled,
"the simplify button is available for a selected freehand"
)
_check(
controller.can_simplify_selected_freehand(),
"a multi-point freehand can be simplified"
)
controller.simplify_button.pressed.emit()
_check(
simplify_segment.curve.point_count < simplify_points.size(),
"the simplify button reduces the point count"
)
_check_vec(
simplify_segment.curve.get_point_position(0),
simplify_points[0],
"manual simplification keeps the start point"
)
_check_vec(
simplify_segment.curve.get_point_position(
simplify_segment.curve.point_count - 1
),
simplify_points[simplify_points.size() - 1],
"manual simplification keeps the end point"
)
_check(controller.undo(), "manual simplification can be undone")
var restored_simplify := controller.get_active_section().get_segment_by_id(
"seg-simplify"
)
_check(
restored_simplify != null
and restored_simplify.curve.point_count == simplify_points.size(),
"undo restores the dense freehand points"
)
scene.queue_free()
await process_frame
_finish()