From 55e7b163b522f69c81adcaf7f3ed47a174658bf8 Mon Sep 17 00:00:00 2001 From: torsten Date: Tue, 10 Nov 2026 15:50:03 +0100 Subject: [PATCH] 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 --- docs/architecture.md | 114 +- docs/findings-2026-11-10-freeline.md | 61 + ...ndings-2026-11-10-step-sequence-gruppen.md | 62 + docs/manual.md | 94 +- docs/roadmap.md | 15 + rinkplanner/assets/icons/playback/pause.svg | 4 + .../assets/icons/playback/pause.svg.import | 43 + rinkplanner/assets/icons/playback/play.svg | 4 + .../assets/icons/playback/play.svg.import | 43 + rinkplanner/assets/icons/playback/reset.svg | 5 + .../assets/icons/playback/reset.svg.import | 43 + rinkplanner/assets/icons/tools/freeline.svg | 8 + .../assets/icons/tools/freeline.svg.import | 43 + rinkplanner/scenes/whiteboard/whiteboard.tscn | 328 +++- rinkplanner/src/core/io/routine_file.gd | 41 + rinkplanner/src/core/model/path_segment.gd | 153 ++ .../src/core/model/resolved_element.gd | 177 +++ .../src/core/model/resolved_element.gd.uid | 1 + rinkplanner/src/core/model/routine.gd | 14 +- rinkplanner/src/core/model/routine_section.gd | 137 ++ .../src/core/rules/routine_validator.gd | 10 +- .../whiteboard/ctrl/whiteboard_controller.gd | 1410 +++++++++++++++-- .../src/whiteboard/io/routine_pdf_exporter.gd | 177 ++- rinkplanner/src/whiteboard/io/svg_exporter.gd | 63 +- .../src/whiteboard/view/rink_canvas.gd | 429 ++++- rinkplanner/tests/run_adult_tests.gd | 29 + rinkplanner/tests/run_export_tests.gd | 102 +- rinkplanner/tests/run_file_format_tests.gd | 78 +- rinkplanner/tests/run_model_tests.gd | 216 +++ rinkplanner/tests/run_playback_tests.gd | 92 +- rinkplanner/tests/run_touch_tests.gd | 49 +- rinkplanner/tests/run_validation_tests.gd | 53 + rinkplanner/tests/run_whiteboard_tests.gd | 870 +++++++++- 33 files changed, 4623 insertions(+), 345 deletions(-) create mode 100644 docs/findings-2026-11-10-freeline.md create mode 100644 docs/findings-2026-11-10-step-sequence-gruppen.md create mode 100644 rinkplanner/assets/icons/playback/pause.svg create mode 100644 rinkplanner/assets/icons/playback/pause.svg.import create mode 100644 rinkplanner/assets/icons/playback/play.svg create mode 100644 rinkplanner/assets/icons/playback/play.svg.import create mode 100644 rinkplanner/assets/icons/playback/reset.svg create mode 100644 rinkplanner/assets/icons/playback/reset.svg.import create mode 100644 rinkplanner/assets/icons/tools/freeline.svg create mode 100644 rinkplanner/assets/icons/tools/freeline.svg.import create mode 100644 rinkplanner/src/core/model/resolved_element.gd create mode 100644 rinkplanner/src/core/model/resolved_element.gd.uid diff --git a/docs/architecture.md b/docs/architecture.md index 49f1c7b..22d3cf6 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -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 diff --git a/docs/findings-2026-11-10-freeline.md b/docs/findings-2026-11-10-freeline.md new file mode 100644 index 0000000..47c7e5d --- /dev/null +++ b/docs/findings-2026-11-10-freeline.md @@ -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. diff --git a/docs/findings-2026-11-10-step-sequence-gruppen.md b/docs/findings-2026-11-10-step-sequence-gruppen.md new file mode 100644 index 0000000..02d02e5 --- /dev/null +++ b/docs/findings-2026-11-10-step-sequence-gruppen.md @@ -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. diff --git a/docs/manual.md b/docs/manual.md index 1396f22..b5938a1 100644 --- a/docs/manual.md +++ b/docs/manual.md @@ -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 diff --git a/docs/roadmap.md b/docs/roadmap.md index 0b3de5e..3cabd3e 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -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) diff --git a/rinkplanner/assets/icons/playback/pause.svg b/rinkplanner/assets/icons/playback/pause.svg new file mode 100644 index 0000000..69942b8 --- /dev/null +++ b/rinkplanner/assets/icons/playback/pause.svg @@ -0,0 +1,4 @@ + + + + diff --git a/rinkplanner/assets/icons/playback/pause.svg.import b/rinkplanner/assets/icons/playback/pause.svg.import new file mode 100644 index 0000000..9ce6bd2 --- /dev/null +++ b/rinkplanner/assets/icons/playback/pause.svg.import @@ -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 diff --git a/rinkplanner/assets/icons/playback/play.svg b/rinkplanner/assets/icons/playback/play.svg new file mode 100644 index 0000000..4896646 --- /dev/null +++ b/rinkplanner/assets/icons/playback/play.svg @@ -0,0 +1,4 @@ + + + diff --git a/rinkplanner/assets/icons/playback/play.svg.import b/rinkplanner/assets/icons/playback/play.svg.import new file mode 100644 index 0000000..c3b8d72 --- /dev/null +++ b/rinkplanner/assets/icons/playback/play.svg.import @@ -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 diff --git a/rinkplanner/assets/icons/playback/reset.svg b/rinkplanner/assets/icons/playback/reset.svg new file mode 100644 index 0000000..c749a60 --- /dev/null +++ b/rinkplanner/assets/icons/playback/reset.svg @@ -0,0 +1,5 @@ + + + + diff --git a/rinkplanner/assets/icons/playback/reset.svg.import b/rinkplanner/assets/icons/playback/reset.svg.import new file mode 100644 index 0000000..b92cfd9 --- /dev/null +++ b/rinkplanner/assets/icons/playback/reset.svg.import @@ -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 diff --git a/rinkplanner/assets/icons/tools/freeline.svg b/rinkplanner/assets/icons/tools/freeline.svg new file mode 100644 index 0000000..97a9706 --- /dev/null +++ b/rinkplanner/assets/icons/tools/freeline.svg @@ -0,0 +1,8 @@ + + + + + + + diff --git a/rinkplanner/assets/icons/tools/freeline.svg.import b/rinkplanner/assets/icons/tools/freeline.svg.import new file mode 100644 index 0000000..9f4fe8a --- /dev/null +++ b/rinkplanner/assets/icons/tools/freeline.svg.import @@ -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 diff --git a/rinkplanner/scenes/whiteboard/whiteboard.tscn b/rinkplanner/scenes/whiteboard/whiteboard.tscn index 89eacf0..c58cceb 100644 --- a/rinkplanner/scenes/whiteboard/whiteboard.tscn +++ b/rinkplanner/scenes/whiteboard/whiteboard.tscn @@ -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 diff --git a/rinkplanner/src/core/io/routine_file.gd b/rinkplanner/src/core/io/routine_file.gd index 48261fa..3e591f9 100644 --- a/rinkplanner/src/core/io/routine_file.gd +++ b/rinkplanner/src/core/io/routine_file.gd @@ -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: diff --git a/rinkplanner/src/core/model/path_segment.gd b/rinkplanner/src/core/model/path_segment.gd index caf0b27..7854b2d 100644 --- a/rinkplanner/src/core/model/path_segment.gd +++ b/rinkplanner/src/core/model/path_segment.gd @@ -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") diff --git a/rinkplanner/src/core/model/resolved_element.gd b/rinkplanner/src/core/model/resolved_element.gd new file mode 100644 index 0000000..5145782 --- /dev/null +++ b/rinkplanner/src/core/model/resolved_element.gd @@ -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() diff --git a/rinkplanner/src/core/model/resolved_element.gd.uid b/rinkplanner/src/core/model/resolved_element.gd.uid new file mode 100644 index 0000000..46ca5fb --- /dev/null +++ b/rinkplanner/src/core/model/resolved_element.gd.uid @@ -0,0 +1 @@ +uid://d2v6mcdc3qa1x diff --git a/rinkplanner/src/core/model/routine.gd b/rinkplanner/src/core/model/routine.gd index 90fb4c4..9fdfa12 100644 --- a/rinkplanner/src/core/model/routine.gd +++ b/rinkplanner/src/core/model/routine.gd @@ -4,7 +4,7 @@ extends Resource ## Root aggregate of a choreography. Pure data: no rendering, no input, no ## timing state. The whiteboard view and the future 3D layer both consume it. -const CURRENT_SCHEMA_VERSION := 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: diff --git a/rinkplanner/src/core/model/routine_section.gd b/rinkplanner/src/core/model/routine_section.gd index 4eda1dd..92ecd5b 100644 --- a/rinkplanner/src/core/model/routine_section.gd +++ b/rinkplanner/src/core/model/routine_section.gd @@ -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 diff --git a/rinkplanner/src/core/rules/routine_validator.gd b/rinkplanner/src/core/rules/routine_validator.gd index 51b5d87..f83876a 100644 --- a/rinkplanner/src/core/rules/routine_validator.gd +++ b/rinkplanner/src/core/rules/routine_validator.gd @@ -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() diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index 11711e5..20a511d 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -9,6 +9,7 @@ enum Tool { LINE, ARC_LEFT, ARC_RIGHT, + FREELINE, ELEMENT, } @@ -25,6 +26,16 @@ enum FileAction { const DEFAULT_SPEED_MPS := 4.3 const MIN_SEGMENT_LENGTH_M := 0.3 +## Freehand points are sampled at roughly this screen distance. +const FREELINE_POINT_STEP_PX := 2.5 +## Safety cap for a single freehand curve (the JSON limit is 10,000). +const FREELINE_MAX_POINTS := 4000 +## One button press softens the polyline twice. Start and end stay fixed. +const FREELINE_SMOOTH_ITERATIONS := 2 +const FREELINE_SMOOTH_CENTER_WEIGHT := 0.5 +## Ramer-Douglas-Peucker tolerance in screen pixels. Converted to metres with +## the current zoom when a freehand is finished or simplified. +const FREELINE_SIMPLIFY_TOLERANCE_PX := 1.0 const EPSILON := 0.0001 const MIN_SPEED_MPS := 0.5 const MAX_SPEED_MPS := 12.0 @@ -33,12 +44,18 @@ const DURATION_STEP_SECONDS := 0.1 const MIN_DURATION_SECONDS := 0.1 const MAX_DURATION_SECONDS := 120.0 const DEFAULT_PROFILE_INDEX := 2 -const SPIN_REVOLUTIONS_PER_SECOND := 1.5 +## Visualisation only: how fast the playback marker turns while standing on a +## spin marker. Modern spins rotate around 2-3 rev/s (elite upright/scratch +## spins up to 5); 1.5 rev/s looked too sluggish. See +## docs/speed-assumptions.md, section 8. +const SPIN_REVOLUTIONS_PER_SECOND := 2.5 const ELEMENT_DEFAULT_DURATIONS := { PathSegment.ElementType.JUMP: 0.7, - PathSegment.ElementType.SPIN: 8.0, + PathSegment.ElementType.SPIN: 4.0, PathSegment.ElementType.SEQUENCE: 0.0, } +## Samples per path segment when looking up where a new marker belongs. +const ELEMENT_INSERT_SAMPLES := 32 const PROFILE_NAMES := [ "Adult Bronze", "Adult Silver", @@ -47,10 +64,35 @@ const PROFILE_NAMES := [ "Elite", ] const PROFILE_SPEEDS := [3.0, 3.8, 4.3, 5.0, 6.0] +## Tool order of the icon buttons in the top bar. The element tools share +## [constant Tool.ELEMENT]; TOOL_ELEMENT_TYPES picks the marker type. +const TOOL_ORDER := [ + Tool.SELECT, + Tool.LINE, + Tool.ARC_LEFT, + Tool.ARC_RIGHT, + Tool.FREELINE, + Tool.ELEMENT, + Tool.ELEMENT, + Tool.ELEMENT, +] +## Element type of each tool button; NONE for path tools. +const TOOL_ELEMENT_TYPES := [ + PathSegment.ElementType.NONE, + PathSegment.ElementType.NONE, + PathSegment.ElementType.NONE, + PathSegment.ElementType.NONE, + PathSegment.ElementType.NONE, + PathSegment.ElementType.JUMP, + PathSegment.ElementType.SPIN, + PathSegment.ElementType.SEQUENCE, +] const ROUTINES_DIR := "user://routines" const EXPORTS_DIR := "user://exports" const EXPORT_SHEET_SCENE := preload("res://scenes/export/export_sheet.tscn") const PRESENTATION_3D_SCENE_PATH := "res://scenes/presentation3d/presentation_3d.tscn" +const PLAYBACK_PLAY_ICON := preload("res://assets/icons/playback/play.svg") +const PLAYBACK_PAUSE_ICON := preload("res://assets/icons/playback/pause.svg") const ELEMENT_CATALOG_SCRIPT := preload("res://src/core/rules/element_catalog.gd") const ELEMENT_LEVEL_RULES_SCRIPT := preload("res://src/core/rules/element_level_rules.gd") const ROUTINE_VALIDATOR_SCRIPT := preload("res://src/core/rules/routine_validator.gd") @@ -67,7 +109,9 @@ const SYNC_SETTINGS_PATH := "user://sync.cfg" const SYNC_PROVIDERS := ["dropbox", "google_drive"] const AUTOSAVE_DELAY_SECONDS := 1.5 const MAX_HISTORY := 50 -const COMPACT_LAYOUT_WIDTH := 1280.0 +## Below this width the toolbar switches to short labels so the top bar keeps +## fitting without clipping when the tool icons are shown. +const COMPACT_LAYOUT_WIDTH := 1390.0 ## Music playback and the routine timeline share one clock. Tiny differences ## are normal (output latency, dropped frames); only larger drift is corrected. const MUSIC_DRIFT_TOLERANCE_SECONDS := 0.35 @@ -79,13 +123,23 @@ const MAX_MUSIC_FILE_BYTES := 64 * 1024 * 1024 @onready var rink_canvas: RinkCanvas = %RinkCanvas @onready var title_label: Label = %Title -@onready var tool_label: Label = %ToolLabel @onready var timing_title: Label = %TimingTitle @onready var timing_separator_1: VSeparator = %TimingSeparator1 @onready var timing_separator_2: VSeparator = %TimingSeparator2 @onready var timing_separator_3: VSeparator = %TimingSeparator3 @onready var sections_panel: PanelContainer = %SectionsPanel -@onready var tool_option: OptionButton = %ToolOption +@onready var tool_buttons_container: HBoxContainer = %ToolButtons +## Order must match the buttons in the scene's ToolButtons container. +@onready var tool_buttons: Array[Button] = [ + %SelectToolButton, + %LineToolButton, + %ArcLeftToolButton, + %ArcRightToolButton, + %FreeLineToolButton, + %JumpToolButton, + %SpinToolButton, + %SequenceToolButton, +] @onready var forward_button: Button = %ForwardButton @onready var backward_button: Button = %BackwardButton @onready var inside_button: Button = %InsideButton @@ -107,6 +161,8 @@ const MAX_MUSIC_FILE_BYTES := 64 * 1024 * 1024 @onready var move_down_button: Button = %MoveDownButton @onready var rename_button: Button = %RenameButton @onready var delete_button: Button = %DeleteButton +@onready var multi_select_button: Button = %MultiSelectButton +@onready var group_sequence_button: Button = %GroupSequenceButton @onready var rename_dialog: ConfirmationDialog = %RenameDialog @onready var rename_edit: LineEdit = %RenameEdit @onready var delete_dialog: ConfirmationDialog = %DeleteDialog @@ -137,6 +193,8 @@ const MAX_MUSIC_FILE_BYTES := 64 * 1024 * 1024 @onready var label_button: Button = %LabelButton @onready var labels_toggle: Button = %LabelsToggle @onready var element_button: Button = %ElementButton +@onready var smooth_button: Button = %SmoothButton +@onready var simplify_button: Button = %SimplifyButton @onready var element_type_option: OptionButton = %ElementTypeOption @onready var element_dialog: ConfirmationDialog = %ElementDialog @onready var element_dialog_type_option: OptionButton = %ElementDialogTypeOption @@ -165,6 +223,11 @@ const MAX_MUSIC_FILE_BYTES := 64 * 1024 * 1024 @onready var help_dialog: AcceptDialog = %HelpDialog @onready var help_text: RichTextLabel = %HelpText @onready var element_duration_spin: SpinBox = %ElementDurationSpin +@onready var element_revolutions_box: VBoxContainer = %RevolutionsBox +@onready var element_revolutions_label: Label = %ElementRevolutionsLabel +@onready var element_revolutions_spin: SpinBox = %ElementRevolutionsSpin +@onready var element_rotation_box: VBoxContainer = %RotationBox +@onready var element_rotation_option: OptionButton = %ElementRotationOption @onready var segment_label_dialog: ConfirmationDialog = %SegmentLabelDialog @onready var segment_label_edit: LineEdit = %SegmentLabelEdit @onready var duration_minus_button: Button = %DurationMinusButton @@ -205,10 +268,16 @@ var _routine: Routine var _active_section: RoutineSection var _current_segment: PathSegment var _selected_segment_id: String = "" +var _selected_segment_ids: Array[String] = [] +var _multi_select_enabled: bool = false var _segment_counter: int = 0 +var _element_group_counter: int = 0 var _section_counter: int = 1 +## While sequence mode is active, newly drawn path segments join this group. +var _sequence_mode: bool = false +var _open_sequence_id: String = "" var _section_buttons: Dictionary[String, Button] = {} -var _tool: Tool = Tool.LINE +var _tool: Tool = Tool.SELECT var _direction: PathSegment.Direction = PathSegment.Direction.FORWARD var _edge: PathSegment.Edge = PathSegment.Edge.OUTSIDE var _element_type: PathSegment.ElementType = PathSegment.ElementType.JUMP @@ -256,6 +325,7 @@ var _view_3d_active: bool = false func _ready() -> void: + _maximize_window_on_desktop.call_deferred() autosave_timer.wait_time = AUTOSAVE_DELAY_SECONDS _element_catalog = ELEMENT_CATALOG_SCRIPT.load_default() if not _element_catalog.get_errors().is_empty(): @@ -276,7 +346,7 @@ func _ready() -> void: "Prüft Kürzel, Elementtyp, Level, Features und Einmal-Regeln (Saison %s)" % _element_catalog.season ) - _setup_tool_options() + _setup_tool_buttons() _setup_file_menu() _setup_playback_controls() _setup_timing_controls() @@ -285,7 +355,6 @@ func _ready() -> void: _setup_export_controls() labels_toggle.set_pressed_no_signal(rink_canvas.labels_visible) - tool_option.item_selected.connect(_on_tool_selected) forward_button.pressed.connect( _on_direction_pressed.bind(PathSegment.Direction.FORWARD) ) @@ -312,6 +381,7 @@ func _ready() -> void: rink_canvas.draw_cancelled.connect(_on_draw_cancelled) rink_canvas.marker_requested.connect(_on_marker_requested) rink_canvas.segment_selected.connect(_on_segment_selected) + rink_canvas.segment_selection_toggled.connect(_on_segment_selection_toggled) rink_canvas.selection_cleared.connect(_on_selection_cleared) rink_canvas.segment_handle_drag_started.connect(_on_handle_drag_started) rink_canvas.segment_handle_dragged.connect(_on_handle_dragged) @@ -356,10 +426,14 @@ func _ready() -> void: cloud_auth_dialog.confirmed.connect(_on_cloud_auth_confirmed) cloud_auth_dialog.canceled.connect(_on_cloud_auth_canceled) label_button.pressed.connect(_open_label_dialog) + multi_select_button.toggled.connect(_on_multi_select_toggled) + group_sequence_button.pressed.connect(_on_group_sequence_pressed) labels_toggle.toggled.connect(_on_labels_toggled) segment_label_dialog.confirmed.connect(_on_label_confirmed) segment_label_edit.text_submitted.connect(_on_label_submitted) element_button.pressed.connect(_open_element_dialog) + smooth_button.pressed.connect(smooth_selected_freehand) + simplify_button.pressed.connect(simplify_selected_freehand) element_dialog.confirmed.connect(_on_element_confirmed) validation_button.pressed.connect(open_validation_dialog) validation_text.meta_clicked.connect(_on_validation_meta_clicked) @@ -454,6 +528,76 @@ func get_selected_segment() -> PathSegment: return _find_segment(_selected_segment_id) +func get_selected_segment_ids() -> PackedStringArray: + var ids := PackedStringArray() + for segment_id: String in _selected_segment_ids: + ids.append(segment_id) + return ids + + +func is_multi_select_enabled() -> bool: + return _multi_select_enabled + + +func set_multi_select_enabled(enabled: bool) -> void: + if enabled and _tool != Tool.SELECT: + _apply_tool(Tool.SELECT) + _multi_select_enabled = enabled + multi_select_button.set_pressed_no_signal(enabled) + rink_canvas.set_multi_select_enabled(enabled) + _update_group_sequence_buttons() + _update_status() + + +func _on_multi_select_toggled(pressed: bool) -> void: + _multi_select_enabled = pressed + rink_canvas.set_multi_select_enabled(pressed) + _update_group_sequence_buttons() + _update_status() + + +## Replaces the complete selection. The primary segment drives the existing +## single-selection inspector and geometry controls. +func _set_selection(segment_ids: PackedStringArray, primary_id: String = "") -> void: + _selected_segment_ids.clear() + for segment_id: String in segment_ids: + if _find_segment(segment_id) != null 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 = "" + + rink_canvas.set_selected_segments( + get_selected_segment_ids(), + _selected_segment_id + ) + _sync_toolbar_to_selection() + _update_group_sequence_buttons() + _update_status() + + +## Resolves the selected segment to its scoring element. Returns null for plain +## path segments and for members of an invalid group without a lead. +func get_selected_element() -> ResolvedElement: + var segment := get_selected_segment() + if segment == null or _active_section == null: + return null + return _active_section.get_element_for_segment(segment.segment_id) + + +## Lead segment of the selected element. Element edits always target the lead; +## geometry and timing edits keep using [method get_selected_segment]. +func get_selected_element_lead() -> PathSegment: + var element := get_selected_element() + if element != null: + return element.get_lead() + return get_selected_segment() + + func get_selected_segment_label() -> String: var segment := get_selected_segment() return segment.label if segment != null else "" @@ -520,9 +664,8 @@ func get_element_type() -> PathSegment.ElementType: ## touched; the toolbar option applies to the selection separately. func set_element_type(type: PathSegment.ElementType) -> void: _element_type = type - var index := element_type_option.get_item_index(type) - if index >= 0: - element_type_option.select(index) + _sync_element_type_option() + _update_tool_buttons() func get_element_level() -> int: @@ -1050,7 +1193,7 @@ func _apply_score_assumptions() -> void: func get_selected_element_features() -> PackedStringArray: - var segment := get_selected_segment() + var segment := get_selected_element_lead() if segment == null: return PackedStringArray() return segment.element_features.duplicate() @@ -1059,7 +1202,7 @@ func get_selected_element_features() -> PackedStringArray: ## Replaces the feature selection of the selected element and, for catalog ## elements, the derived level. Returns true when the model changed. func set_selected_element_features(features: PackedStringArray) -> bool: - var segment := get_selected_segment() + var segment := get_selected_element_lead() if segment == null or not segment.is_element(): return false @@ -1099,7 +1242,7 @@ func update_element_feature_hint() -> void: element_features_button.text = "Features (0)" element_features_button.disabled = true - var segment := get_selected_segment() + var segment := get_selected_element_lead() if segment == null or not segment.is_element(): element_feature_hint.text = "Kein Element ausgewählt." return @@ -1313,7 +1456,7 @@ func update_element_value_hint() -> void: func get_selected_element_caption() -> String: - var segment := get_selected_segment() + var segment := get_selected_element_lead() return segment.get_element_caption() if segment != null else "" @@ -1602,7 +1745,34 @@ func _select_jump_extra(option: OptionButton, code: String) -> void: func _on_element_dialog_type_selected(index: int) -> void: var type: PathSegment.ElementType = element_dialog_type_option.get_item_id(index) - var segment := get_selected_segment() + var segment := get_selected_element_lead() + var was_spin := ( + segment != null and segment.element_type == PathSegment.ElementType.SPIN + ) + var is_spin := type == PathSegment.ElementType.SPIN + var rotates := is_spin or type == PathSegment.ElementType.JUMP + var was_rotating := ( + segment != null + and ( + segment.element_type == PathSegment.ElementType.SPIN + or segment.element_type == PathSegment.ElementType.JUMP + ) + ) + element_revolutions_box.visible = is_spin + element_rotation_box.visible = rotates + if is_spin and not was_spin: + # A spin needs its own stand time; adopt the type default and derive a + # starting revolution count that keeps the familiar visual rate. + var default_seconds := float(ELEMENT_DEFAULT_DURATIONS.get(type, 0.0)) + element_duration_spin.set_value_no_signal(default_seconds) + element_revolutions_spin.set_value_no_signal( + _default_spin_revolutions(default_seconds) + ) + if not was_rotating: + element_rotation_option.select(0) + elif not rotates: + element_revolutions_spin.set_value_no_signal(0.0) + _update_spin_revolutions_hint() if segment != null and type != segment.element_type: _dialog_features = PackedStringArray() if type != PathSegment.ElementType.JUMP: @@ -1665,7 +1835,7 @@ func set_selected_element( level: int, duration: float = -1.0 ) -> bool: - var segment := get_selected_segment() + var segment := get_selected_element_lead() var features := ( segment.element_features if segment != null else PackedStringArray() ) @@ -1700,15 +1870,33 @@ func set_selected_element_with_features( features: PackedStringArray, duration: float = -1.0, jump_kind: PathSegment.JumpKind = PathSegment.JumpKind.SOLO, - combination_jumps: PackedStringArray = PackedStringArray() + combination_jumps: PackedStringArray = PackedStringArray(), + revolutions: float = -1.0, + rotation_direction: int = -1 ) -> bool: - var segment := get_selected_segment() + var element := get_selected_element() + var segment := element.get_lead() if element != null else get_selected_segment() if segment == null: return false - if type == PathSegment.ElementType.NONE and segment.is_element_marker(): - # A point marker without an element has no meaning: remove it entirely. - return delete_selected_segment() + if type == PathSegment.ElementType.NONE: + if segment.is_element_marker(): + # A point marker without an element has no meaning: remove it. + return delete_selected_segment() + if element != null and element.segments.size() > 1: + return _clear_element_group(element) + elif ( + element != null + and element.segments.size() > 1 + and type != PathSegment.ElementType.SEQUENCE + ): + # A sequence range keeps its type; ungroup it before changing it to a + # jump or spin. + _show_message( + "Eine Sequenzgruppe kann nur als Sequenz bearbeitet werden. " + + "Wähle „Kein Element“, um die Gruppe aufzulösen." + ) + return false var cleaned := code.strip_edges().left(PathSegment.ELEMENT_CODE_MAX_LENGTH) var clamped := clampi(level, 0, PathSegment.ELEMENT_MAX_LEVEL) @@ -1761,6 +1949,44 @@ func set_selected_element_with_features( else: clamped_duration = 0.0 + var clamped_revolutions := 0.0 + var clamped_direction: int = ( + PathSegment.RotationDirection.COUNTERCLOCKWISE + ) + if type == PathSegment.ElementType.SPIN: + if revolutions >= 0.0: + clamped_revolutions = clampf( + revolutions, + 0.0, + PathSegment.ELEMENT_MAX_REVOLUTIONS + ) + elif ( + segment.element_type == type + and segment.is_element_marker() + ): + clamped_revolutions = segment.element_revolutions + else: + # Switching to a spin: keep the current visual rate as a start. + clamped_revolutions = _default_spin_revolutions(clamped_duration) + if ( + type == PathSegment.ElementType.SPIN + or type == PathSegment.ElementType.JUMP + ): + if rotation_direction >= 0: + clamped_direction = ( + PathSegment.RotationDirection.CLOCKWISE + if rotation_direction == PathSegment.RotationDirection.CLOCKWISE + else PathSegment.RotationDirection.COUNTERCLOCKWISE + ) + elif ( + segment.is_element_marker() + and ( + segment.element_type == PathSegment.ElementType.SPIN + or segment.element_type == PathSegment.ElementType.JUMP + ) + ): + clamped_direction = segment.element_rotation_direction + if ( segment.element_type == type and segment.element_code == cleaned @@ -1769,14 +1995,20 @@ func set_selected_element_with_features( and segment.jump_kind == cleaned_kind and segment.combination_jumps == cleaned_combination and segment.element_duration_seconds == clamped_duration + and segment.element_revolutions == clamped_revolutions + and segment.element_rotation_direction == clamped_direction ): return false _record_undo() + if type == PathSegment.ElementType.NONE: + segment.element_group_id = "" segment.set_element(type, cleaned, clamped) segment.set_element_features(cleaned_features) segment.set_jump_combination(cleaned_kind, cleaned_combination) segment.set_element_duration(maxf(clamped_duration, 0.0)) + segment.set_element_revolutions(clamped_revolutions) + segment.element_rotation_direction = clamped_direction if type != PathSegment.ElementType.NONE: # Keep the placement defaults on the last real element type. _element_type = type @@ -1790,6 +2022,12 @@ func set_selected_element_with_features( return true +## Starting revolution count for a fresh spin marker. Keeps the familiar visual +## rate (SPIN_REVOLUTIONS_PER_SECOND) for the current stand time. +func _default_spin_revolutions(seconds: float) -> float: + return roundf(maxf(seconds, 0.0) * SPIN_REVOLUTIONS_PER_SECOND) + + ## Places a zero-length element marker. The marker is selected so the element ## inspector can refine code and level; the type defaults to the last placed ## element if the caller does not pass one. @@ -1802,6 +2040,7 @@ func add_element_marker( ) -> PathSegment: if _active_section == null: return null + _finish_sequence_mode() if type == PathSegment.ElementType.NONE: type = PathSegment.ElementType.JUMP if _playing or not _playback_section_id.is_empty(): @@ -1833,16 +2072,411 @@ func add_element_marker( if duration < 0.0 else duration ) + if type == PathSegment.ElementType.SPIN: + segment.set_element_revolutions( + _default_spin_revolutions(segment.element_duration_seconds) + ) - _active_section.segments.append(segment) + _active_section.segments.insert(_element_insert_index(position), segment) + _selected_segment_ids.clear() + _selected_segment_ids.append(segment.segment_id) _selected_segment_id = segment.segment_id _mark_dirty() - rink_canvas.set_selected_segment(segment.segment_id) + var marker_ids := PackedStringArray() + marker_ids.append(segment.segment_id) + rink_canvas.set_selected_segments(marker_ids, segment.segment_id) rink_canvas.refresh() _update_status() return segment +## Groups consecutive path segments into one sequence range. All ids must exist +## in the active section, be in section order and not belong to another +## element. Returns the resolved element or null when the selection is invalid. +func group_segments_as_sequence( + segment_ids: PackedStringArray, + code: String = "StSq", + level: int = 0 +) -> ResolvedElement: + if _active_section == null or segment_ids.is_empty(): + return null + + var group: Array[PathSegment] = [] + var first_index := -1 + for segment_id: String in segment_ids: + var index := _segment_index(segment_id) + if index < 0: + return null + var segment: PathSegment = _active_section.segments[index] + if ( + segment == null + or segment.is_marker() + or segment.is_element() + or not segment.element_group_id.is_empty() + ): + return null + if first_index < 0: + first_index = index + elif index != first_index + group.size(): + return null + group.append(segment) + if group.is_empty(): + return null + + _record_undo() + var element := _apply_element_group(group, code, level) + _selected_segment_ids.clear() + _selected_segment_ids.append(group[0].segment_id) + _selected_segment_id = group[0].segment_id + var selected_ids := PackedStringArray() + selected_ids.append(_selected_segment_id) + rink_canvas.set_selected_segments(selected_ids, _selected_segment_id) + _mark_dirty() + rink_canvas.refresh() + _sync_toolbar_to_selection() + _update_status() + update_element_feature_hint() + update_element_value_hint() + return element + + +func _selected_segments_in_section_order() -> Array[PathSegment]: + var selected: Array[PathSegment] = [] + if _active_section == null: + return selected + for segment: PathSegment in _active_section.segments: + if segment != null and _selected_segment_ids.has(segment.segment_id): + selected.append(segment) + return selected + + +## True when the current selection is a contiguous run of plain path segments +## that can become one sequence range. +func can_group_selected_as_sequence() -> bool: + if _active_section == null or _tool != Tool.SELECT or _view_3d_active: + return false + var selected := _selected_segments_in_section_order() + if selected.size() < 2: + return false + for segment: PathSegment in selected: + if ( + segment.is_marker() + or segment.is_element() + or not segment.element_group_id.is_empty() + ): + return false + var first_index := _active_section.segments.find(selected[0]) + if first_index < 0: + return false + for offset: int in range(selected.size()): + if first_index + offset >= _active_section.segments.size(): + return false + if _active_section.segments[first_index + offset] != selected[offset]: + return false + return true + + +## Groups the current multi-selection into one step-sequence range. +func group_selected_as_sequence( + code: String = "StSq", + level: int = 0 +) -> ResolvedElement: + if not can_group_selected_as_sequence(): + return null + var selected := _selected_segments_in_section_order() + var ids := PackedStringArray() + for segment: PathSegment in selected: + ids.append(segment.segment_id) + var element := group_segments_as_sequence(ids, code, level) + if element != null: + set_multi_select_enabled(false) + return element + + +func _on_group_sequence_pressed() -> void: + group_selected_as_sequence() + + +func _update_group_sequence_buttons() -> void: + if group_sequence_button == null or multi_select_button == null: + return + var selected := _selected_segments_in_section_order() + var enabled := can_group_selected_as_sequence() + group_sequence_button.disabled = not enabled + group_sequence_button.text = ( + "Sequenz gruppieren (%d)" % selected.size() + if selected.size() >= 2 + else "Sequenz gruppieren" + ) + if selected.size() < 2: + group_sequence_button.tooltip_text = ( + "Mindestens zwei zusammenhängende Segmente auswählen" + ) + elif not enabled: + group_sequence_button.tooltip_text = ( + "Auswahl muss zusammenhängen und darf keine Elemente enthalten" + ) + else: + group_sequence_button.tooltip_text = ( + "Auswahl als Schrittsequenz gruppieren" + ) + multi_select_button.disabled = _tool != Tool.SELECT or _view_3d_active + multi_select_button.text = ( + "Mehrfachauswahl an" if _multi_select_enabled else "Mehrfachauswahl" + ) + var multi := _selected_segment_ids.size() > 1 + forward_button.disabled = multi + backward_button.disabled = multi + inside_button.disabled = multi + outside_button.disabled = multi + + +func _apply_element_group( + group: Array[PathSegment], + code: String, + level: int +) -> ResolvedElement: + var group_id := _next_element_group_id() + var lead := group[0] + lead.set_element( + PathSegment.ElementType.SEQUENCE, + code, + clampi(level, 0, PathSegment.ELEMENT_MAX_LEVEL) + ) + lead.element_group_id = group_id + for index: int in range(1, group.size()): + var member := group[index] + member.set_element(PathSegment.ElementType.NONE, "", 0) + member.element_group_id = group_id + return _active_section.get_element_by_id(group_id) + + +func _clear_element_group( + element: ResolvedElement, + record_undo: bool = true +) -> bool: + if element == null: + return false + if record_undo: + _record_undo() + for segment: PathSegment in element.segments: + if segment != null: + segment.element_group_id = "" + var lead := element.get_lead() + if lead != null: + lead.set_element(PathSegment.ElementType.NONE, "", 0) + var selection := PackedStringArray() + if lead != null: + selection.append(lead.segment_id) + _set_selection(selection, lead.segment_id if lead != null else "") + _mark_dirty() + rink_canvas.refresh() + _sync_toolbar_to_selection() + _update_status() + update_element_feature_hint() + update_element_value_hint() + return true + + +func _next_element_group_id() -> String: + var existing: Dictionary[String, bool] = {} + for section: RoutineSection in _routine.sections: + if section == null: + continue + for segment: PathSegment in section.segments: + if segment == null: + continue + existing[segment.segment_id] = true + if not segment.element_group_id.is_empty(): + existing[segment.element_group_id] = true + + _element_group_counter += 1 + while existing.has("el-%03d" % _element_group_counter): + _element_group_counter += 1 + return "el-%03d" % _element_group_counter + + +func is_sequence_mode() -> bool: + return _sequence_mode + + +func _toggle_sequence_mode() -> void: + if _sequence_mode: + _finish_sequence_mode() + _apply_tool(Tool.SELECT) + return + + _sequence_mode = true + _open_sequence_id = "" + var selected_element := get_selected_element() + if ( + selected_element != null + and selected_element.is_sequence_range() + and _active_section != null + and not _active_section.segments.is_empty() + ): + var last := selected_element.segments[selected_element.segments.size() - 1] + if _active_section.segments[_active_section.segments.size() - 1] == last: + # Continue an existing range when it ends at the section tail. + _open_sequence_id = selected_element.element_id + _element_type = PathSegment.ElementType.SEQUENCE + _sync_element_type_option() + if ( + _tool != Tool.LINE + and _tool != Tool.ARC_LEFT + and _tool != Tool.ARC_RIGHT + and _tool != Tool.FREELINE + ): + _apply_tool(Tool.LINE) + else: + _update_tool_buttons() + _update_status() + + +func _finish_sequence_mode() -> void: + if not _sequence_mode and _open_sequence_id.is_empty(): + return + _sequence_mode = false + _open_sequence_id = "" + _update_tool_buttons() + _update_status() + + +## Adds a freshly drawn segment to the open sequence. The first segment of a +## run becomes the lead; following segments only join the group. +func _join_open_sequence(segment: PathSegment) -> void: + if not _sequence_mode or _active_section == null or segment == null: + return + if _open_sequence_id.is_empty(): + _open_sequence_id = _next_element_group_id() + segment.set_element( + PathSegment.ElementType.SEQUENCE, + "StSq", + 0 + ) + segment.element_group_id = _open_sequence_id + return + + var element := _active_section.get_element_by_id(_open_sequence_id) + if element == null: + _open_sequence_id = "" + _join_open_sequence(segment) + return + if element.get_group_id().is_empty(): + # Continue an older single-segment range: promote it to a real group + # so the new segment can join it. + var group_id := _next_element_group_id() + for member: PathSegment in element.segments: + if member != null: + member.element_group_id = group_id + _open_sequence_id = group_id + element = _active_section.get_element_by_id(group_id) + if element == null: + _open_sequence_id = "" + _join_open_sequence(segment) + return + var last := element.segments[element.segments.size() - 1] + var last_index := _active_section.segments.find(last) + var index := _active_section.segments.find(segment) + if index != last_index + 1: + # A gap means a new sequence run starts here; the previous group stays + # valid with its existing segments. + _open_sequence_id = "" + _join_open_sequence(segment) + return + segment.set_element(PathSegment.ElementType.NONE, "", 0) + segment.element_group_id = _open_sequence_id + + +func _segment_index(segment_id: String) -> int: + if _active_section == null: + return -1 + for index: int in range(_active_section.segments.size()): + var segment: PathSegment = _active_section.segments[index] + if segment != null and segment.segment_id == segment_id: + return index + return -1 + + +## Chronological insert position for a new marker. The drawn path defines the +## order, so the nearest point on the path decides whether the marker belongs +## before or after a segment. That keeps taps at the beginning or between two +## existing elements at the right place instead of always appending. +func _element_insert_index(position: Vector2) -> int: + if _active_section == null: + return 0 + + var path_count := 0 + for segment: PathSegment in _active_section.segments: + if segment != null and not segment.is_element_marker(): + path_count += 1 + + var best_slot := path_count + var best_distance := INF + var path_index := 0 + for segment: PathSegment in _active_section.segments: + if segment == null or segment.is_element_marker(): + continue + var length := 0.0 + if segment.curve != null: + length = segment.curve.get_baked_length() + if length > EPSILON: + var closest_fraction := 0.0 + var closest_distance := INF + for sample: int in range(ELEMENT_INSERT_SAMPLES + 1): + var fraction := float(sample) / float(ELEMENT_INSERT_SAMPLES) + var point := segment.curve.sample_baked(length * fraction) + var distance := position.distance_squared_to(point) + if distance < closest_distance: + closest_distance = distance + closest_fraction = fraction + if closest_distance < best_distance: + best_distance = closest_distance + best_slot = path_index if closest_fraction < 0.5 else path_index + 1 + path_index += 1 + + return _slot_insert_index(best_slot) + + +## Raw array index for the gap after [param path_slot] path segments. Markers +## already in that gap stay in place; the new marker is appended after them so +## repeated taps at the same spot keep their tap order. +func _slot_insert_index(path_slot: int) -> int: + var segments := _active_section.segments + var index := 0 + var passed_paths := 0 + while index < segments.size() and passed_paths < path_slot: + var segment: PathSegment = segments[index] + if segment != null and not segment.is_element_marker(): + passed_paths += 1 + index += 1 + while index < segments.size(): + var segment: PathSegment = segments[index] + if segment == null or not segment.is_element_marker(): + break + index += 1 + + # Never insert between two members of the same sequence group: that would + # split the group. Move the insertion point behind the group instead. + while index > 0 and index < segments.size(): + var previous: PathSegment = segments[index - 1] + var following: PathSegment = segments[index] + if ( + previous == null + or following == null + or previous.element_group_id.is_empty() + or previous.element_group_id != following.element_group_id + ): + break + var group_id := previous.element_group_id + while index < segments.size(): + var candidate: PathSegment = segments[index] + if candidate == null or candidate.element_group_id != group_id: + break + index += 1 + return index + + func _on_marker_requested(model_point: Vector2) -> void: add_element_marker(model_point, _element_type, "", _element_level) @@ -1862,6 +2496,17 @@ func _setup_element_controls() -> void: element_dialog_type_option.add_item("Pirouette", PathSegment.ElementType.SPIN) element_dialog_type_option.add_item("Sequenz", PathSegment.ElementType.SEQUENCE) + element_rotation_option.clear() + element_rotation_option.add_item( + "Linksherum", + PathSegment.RotationDirection.COUNTERCLOCKWISE + ) + element_rotation_option.add_item( + "Rechtsherum", + PathSegment.RotationDirection.CLOCKWISE + ) + element_rotation_option.select(0) + element_level_option.clear() element_level_option.add_item("Base", 0) for level: int in range(1, PathSegment.ELEMENT_MAX_LEVEL + 1): @@ -1885,6 +2530,8 @@ func _setup_element_controls() -> void: element_code_edit.text_changed.connect(_on_element_code_text_changed) element_code_option.item_selected.connect(_on_element_code_option_selected) element_level_option.item_selected.connect(_on_element_value_option_selected) + element_duration_spin.value_changed.connect(_on_spin_timing_changed) + element_revolutions_spin.value_changed.connect(_on_spin_timing_changed) element_dialog_type_option.item_selected.connect( _on_element_dialog_type_selected ) @@ -1964,10 +2611,24 @@ func _on_element_value_option_selected(_index: int) -> void: update_element_value_hint() +func _on_spin_timing_changed(_value: float) -> void: + _update_spin_revolutions_hint() + + +## Shows the rotation rate that follows from revolutions / stand time in the +## element dialog. +func _update_spin_revolutions_hint() -> void: + var seconds := element_duration_spin.value + var rate := 0.0 + if seconds > 0.0: + rate = element_revolutions_spin.value / seconds + element_revolutions_label.text = "Umdrehungen · %s U/s" % _format_decimal(rate) + + func _on_element_type_selected(index: int) -> void: var type: PathSegment.ElementType = element_type_option.get_item_id(index) - _element_type = type - var selected := get_selected_segment() + set_element_type(type) + var selected := get_selected_element_lead() if selected == null: return set_selected_element( @@ -1979,7 +2640,7 @@ func _on_element_type_selected(index: int) -> void: func _open_element_dialog() -> void: - var segment := get_selected_segment() + var segment := get_selected_element_lead() if segment == null: return @@ -2017,6 +2678,25 @@ func _open_element_dialog() -> void: else "Sequenzbereiche nutzen die Segmentdauer in der Timing-Leiste" ) + var is_spin := segment.element_type == PathSegment.ElementType.SPIN + var rotates := ( + is_spin + or segment.element_type == PathSegment.ElementType.JUMP + ) + element_revolutions_box.visible = is_spin + element_rotation_box.visible = rotates + var revolutions := segment.element_revolutions + if is_spin and revolutions <= 0.0: + revolutions = _default_spin_revolutions( + segment.element_duration_seconds + ) + element_revolutions_spin.set_value_no_signal(revolutions if is_spin else 0.0) + var rotation_index := element_rotation_option.get_item_index( + segment.element_rotation_direction + ) + element_rotation_option.select(rotation_index if rotation_index >= 0 else 0) + _update_spin_revolutions_hint() + element_dialog.popup_centered(Vector2i(520, 460)) if element_code_edit.visible: element_code_edit.grab_focus() @@ -2039,7 +2719,9 @@ func _on_element_confirmed() -> void: _dialog_features, element_duration_spin.value, _dialog_jump_kind, - _dialog_combination_jumps + _dialog_combination_jumps, + element_revolutions_spin.value, + element_rotation_option.get_item_id(element_rotation_option.selected) ) @@ -2065,14 +2747,19 @@ func set_active_section(section_id: String) -> void: if section == null: return + _finish_sequence_mode() if _playing: pause() var start_time := get_section_start_time(section_id) rink_canvas.cancel_interaction() _active_section = section + _selected_segment_ids.clear() _selected_segment_id = "" - rink_canvas.set_selected_segment("") + _multi_select_enabled = false + multi_select_button.set_pressed_no_signal(false) + rink_canvas.set_multi_select_enabled(false) + rink_canvas.set_selected_segments(PackedStringArray(), "") rink_canvas.set_active_section(section.section_id) _update_section_buttons() _update_status() @@ -2176,19 +2863,17 @@ func select_segment(segment_id: String) -> void: return if _tool != Tool.SELECT: set_tool(Tool.SELECT) - _selected_segment_id = segment_id - rink_canvas.set_selected_segment(segment_id) - _sync_toolbar_to_selection() - _update_status() + if _multi_select_enabled: + set_multi_select_enabled(false) + var ids := PackedStringArray() + ids.append(segment_id) + _set_selection(ids, segment_id) update_element_feature_hint() ## Selects a tool programmatically and keeps the toolbar in sync. func set_tool(tool: Tool) -> void: _apply_tool(tool) - var index := tool_option.get_item_index(tool) - if index >= 0: - tool_option.select(index) ## Adds a complete segment programmatically. Also used by template tools and @@ -2329,6 +3014,7 @@ func _clone_segment(source: PathSegment) -> PathSegment: clone.speed_mps = source.speed_mps clone.timing_mode = source.timing_mode clone.element_id = source.element_id + clone.element_group_id = source.element_group_id clone.element_type = source.element_type clone.element_code = source.element_code clone.element_level = source.element_level @@ -2336,6 +3022,9 @@ func _clone_segment(source: PathSegment) -> PathSegment: clone.jump_kind = source.jump_kind clone.combination_jumps = source.combination_jumps.duplicate() clone.element_duration_seconds = source.element_duration_seconds + clone.element_revolutions = source.element_revolutions + clone.element_rotation_direction = source.element_rotation_direction + clone.element_jump_vector = source.element_jump_vector clone.label = source.label clone.template = source.template clone.arc_depth_ratio = source.arc_depth_ratio @@ -2356,28 +3045,58 @@ func _clone_segment(source: PathSegment) -> PathSegment: func clear_selection() -> void: - if _selected_segment_id.is_empty(): + if _selected_segment_id.is_empty() and _selected_segment_ids.is_empty(): return - _selected_segment_id = "" - rink_canvas.set_selected_segment("") - _update_status() + _set_selection(PackedStringArray(), "") func delete_selected_segment() -> bool: + if _selected_segment_ids.size() > 1: + return false var segment := get_selected_segment() if segment == null or _active_section == null: return false + var element := _active_section.get_element_for_segment(segment.segment_id) _record_undo() + if element != null and element.get_lead() == segment: + _promote_element_lead(element, segment) _active_section.segments.erase(segment) + _selected_segment_ids.clear() _selected_segment_id = "" _mark_dirty() - rink_canvas.set_selected_segment("") + rink_canvas.set_selected_segments(PackedStringArray(), "") rink_canvas.refresh() _update_status() return true +## Moves the element data to the next member before the lead segment is +## removed, so the sequence group keeps its code, level and features. +func _promote_element_lead(element: ResolvedElement, removed: PathSegment) -> void: + for segment: PathSegment in element.segments: + if segment != null and segment != removed: + _copy_element_fields(removed, segment) + return + + +func _copy_element_fields(source: PathSegment, target: PathSegment) -> void: + if source == null or target == null: + return + target.element_id = source.element_id + target.element_group_id = source.element_group_id + target.element_type = source.element_type + target.element_code = source.element_code + target.element_level = source.element_level + target.element_features = source.element_features.duplicate() + target.jump_kind = source.jump_kind + target.combination_jumps = source.combination_jumps.duplicate() + target.element_duration_seconds = source.element_duration_seconds + target.element_revolutions = source.element_revolutions + target.element_rotation_direction = source.element_rotation_direction + target.element_jump_vector = source.element_jump_vector + + func _unhandled_key_input(event: InputEvent) -> void: if not (event is InputEventKey): return @@ -2405,7 +3124,13 @@ func _unhandled_key_input(event: InputEvent) -> void: get_viewport().set_input_as_handled() return if key.keycode == KEY_ESCAPE: - clear_selection() + if _sequence_mode: + _finish_sequence_mode() + _apply_tool(Tool.SELECT) + else: + clear_selection() + if _multi_select_enabled: + set_multi_select_enabled(false) get_viewport().set_input_as_handled() return if key.keycode != KEY_DELETE and key.keycode != KEY_BACKSPACE: @@ -2424,49 +3149,96 @@ func _any_modal_open() -> bool: return false -func _setup_tool_options() -> void: - tool_option.clear() - tool_option.add_item("Auswählen", Tool.SELECT) - tool_option.add_item("Linie", Tool.LINE) - tool_option.add_item("Bogen links", Tool.ARC_LEFT) - tool_option.add_item("Bogen rechts", Tool.ARC_RIGHT) - tool_option.add_item("Element", Tool.ELEMENT) - tool_option.select(tool_option.get_item_index(Tool.LINE)) - _apply_tool(Tool.LINE) +func _setup_tool_buttons() -> void: + for index: int in range(tool_buttons.size()): + if index >= TOOL_ORDER.size(): + break + tool_buttons[index].pressed.connect( + _on_tool_button_pressed.bind(index) + ) + _apply_tool(Tool.SELECT) -func _on_tool_selected(index: int) -> void: - _apply_tool(_tool_from_id(tool_option.get_item_id(index))) +## Applies the tool behind a palette button. The three element buttons also pick +## the marker type that the next tap places. +func _on_tool_button_pressed(index: int) -> void: + if index < 0 or index >= TOOL_ORDER.size(): + return + var element_type: PathSegment.ElementType = ( + TOOL_ELEMENT_TYPES[index] + if index < TOOL_ELEMENT_TYPES.size() + else PathSegment.ElementType.NONE + ) + if element_type == PathSegment.ElementType.SEQUENCE: + _toggle_sequence_mode() + return + if element_type != PathSegment.ElementType.NONE: + _element_type = element_type + _sync_element_type_option() + _apply_tool(TOOL_ORDER[index]) func _apply_tool(tool: Tool) -> void: + if ( + _sequence_mode + and tool != Tool.LINE + and tool != Tool.ARC_LEFT + and tool != Tool.ARC_RIGHT + and tool != Tool.FREELINE + ): + _finish_sequence_mode() _tool = tool var selecting := tool == Tool.SELECT var placing := tool == Tool.ELEMENT + if not selecting and _multi_select_enabled: + _multi_select_enabled = false + multi_select_button.set_pressed_no_signal(false) + rink_canvas.set_multi_select_enabled(false) rink_canvas.set_drawing_enabled(not selecting and not placing) rink_canvas.set_selection_enabled(selecting) rink_canvas.set_marker_placement_enabled(placing) + _update_tool_buttons() + _update_group_sequence_buttons() _update_status() -func _tool_from_id(tool_id: int) -> Tool: - match tool_id: - Tool.SELECT: - return Tool.SELECT - Tool.LINE: - return Tool.LINE - Tool.ARC_LEFT: - return Tool.ARC_LEFT - Tool.ARC_RIGHT: - return Tool.ARC_RIGHT - Tool.ELEMENT: - return Tool.ELEMENT - return Tool.LINE +## Highlights the icon of the active tool. The pressed icon itself is drawn +## brighter through the Button theme color overrides. For the element buttons +## the planned marker type decides which one is highlighted. +func _update_tool_buttons() -> void: + for index: int in range(tool_buttons.size()): + if index >= TOOL_ORDER.size(): + break + var pressed: bool = TOOL_ORDER[index] == _tool + var element_type: PathSegment.ElementType = ( + TOOL_ELEMENT_TYPES[index] + if index < TOOL_ELEMENT_TYPES.size() + else PathSegment.ElementType.NONE + ) + if element_type == PathSegment.ElementType.SEQUENCE: + pressed = _sequence_mode or ( + TOOL_ORDER[index] == _tool + and _element_type == PathSegment.ElementType.SEQUENCE + ) + elif pressed and TOOL_ORDER[index] == Tool.ELEMENT: + pressed = element_type == _element_type + tool_buttons[index].set_pressed_no_signal(pressed) + + +func _sync_element_type_option() -> void: + var index := element_type_option.get_item_index(_element_type) + if index < 0: + return + element_type_option.set_block_signals(true) + element_type_option.select(index) + element_type_option.set_block_signals(false) func _on_direction_pressed(direction: PathSegment.Direction) -> void: _direction = direction _update_direction_buttons() + if _selected_segment_ids.size() > 1: + return var selected := get_selected_segment() if selected != null and not selected.is_element_marker(): @@ -2480,6 +3252,8 @@ func _on_direction_pressed(direction: PathSegment.Direction) -> void: func _on_edge_pressed(edge: PathSegment.Edge) -> void: _edge = edge _update_edge_buttons() + if _selected_segment_ids.size() > 1: + return var selected := get_selected_segment() if selected != null and not selected.is_element_marker(): @@ -2498,6 +3272,8 @@ func _on_draw_started(model_point: Vector2) -> void: _pending_history = _make_history_entry() _current_segment = _create_segment(model_point, _direction, _edge) + if _tool == Tool.FREELINE: + _prepare_freehand_segment(_current_segment, model_point) _active_section.segments.append(_current_segment) rink_canvas.refresh() @@ -2505,7 +3281,10 @@ func _on_draw_started(model_point: Vector2) -> void: func _on_draw_updated(model_point: Vector2) -> void: if _current_segment == null: return - _update_segment_geometry(_current_segment, model_point, _tool) + if _tool == Tool.FREELINE: + _append_freehand_point(_current_segment, model_point) + else: + _update_segment_geometry(_current_segment, model_point, _tool) rink_canvas.refresh() @@ -2513,14 +3292,25 @@ func _on_draw_finished(model_point: Vector2) -> void: if _current_segment == null: return - _update_segment_geometry(_current_segment, model_point, _tool) + if _tool == Tool.FREELINE: + _append_freehand_point(_current_segment, model_point) + _simplify_freehand_segment( + _current_segment, + _freehand_simplify_tolerance_m(), + false + ) + _update_duration(_current_segment) + else: + _update_segment_geometry(_current_segment, model_point, _tool) + var finished := _current_segment var kept := true - if _current_segment.get_length_m() < MIN_SEGMENT_LENGTH_M: - _active_section.segments.erase(_current_segment) + if finished.get_length_m() < MIN_SEGMENT_LENGTH_M: + _active_section.segments.erase(finished) kept = false _current_segment = null if kept: + _join_open_sequence(finished) _push_undo_entry(_pending_history) _mark_dirty() _pending_history = null @@ -2543,18 +3333,29 @@ func _on_segment_selected(segment_id: String) -> void: if _playing or not _playback_section_id.is_empty(): reset_playback() - _selected_segment_id = segment_id - rink_canvas.set_selected_segment(segment_id) - _sync_toolbar_to_selection() - _update_status() + var ids := PackedStringArray() + ids.append(segment_id) + _set_selection(ids, segment_id) + + +func _on_segment_selection_toggled(_segment_id: String) -> void: + if _playing or not _playback_section_id.is_empty(): + reset_playback() + _set_selection( + rink_canvas.get_selected_segment_ids(), + rink_canvas.get_selected_segment_id() + ) func _on_selection_cleared() -> void: - _selected_segment_id = "" - _update_status() + _set_selection(PackedStringArray(), "") -func _on_handle_drag_started(segment_id: String, _handle: int) -> void: +func _on_handle_drag_started( + segment_id: String, + _handle: int, + _detail: int = 0 +) -> void: _selected_segment_id = segment_id _pending_history = _make_history_entry() _update_status() @@ -2563,13 +3364,14 @@ func _on_handle_drag_started(segment_id: String, _handle: int) -> void: func _on_handle_dragged( segment_id: String, handle: int, - model_point: Vector2 + model_point: Vector2, + detail: int = 0 ) -> void: var segment := _find_segment(segment_id) if segment == null: return - _apply_handle_drag(segment, handle, model_point) + _apply_handle_drag(segment, handle, model_point, detail) _mark_dirty() rink_canvas.refresh() _update_status() @@ -2578,9 +3380,10 @@ func _on_handle_dragged( func _on_handle_drag_finished( segment_id: String, handle: int, - model_point: Vector2 + model_point: Vector2, + detail: int = 0 ) -> void: - _on_handle_dragged(segment_id, handle, model_point) + _on_handle_dragged(segment_id, handle, model_point, detail) _push_undo_entry(_pending_history) _pending_history = null @@ -2588,7 +3391,8 @@ func _on_handle_drag_finished( func _apply_handle_drag( segment: PathSegment, handle: int, - model_point: Vector2 + model_point: Vector2, + detail: int = 0 ) -> void: if segment.curve == null: return @@ -2598,11 +3402,38 @@ func _apply_handle_drag( var shifted := _routine.rink.clamp_point(model_point) segment.curve.clear_points() segment.curve.add_point(shifted) + elif handle == RinkCanvas.Handle.JUMP_TIP: + var marker_point := segment.curve.get_point_position(0) + var vector := _routine.rink.clamp_point(model_point) - marker_point + var length := vector.length() + if length <= 0.000001: + return + # Keep a minimum length so a sloppy tap does not reset the vector to + # "automatic" (zero). + if length < 0.5: + vector = vector.normalized() * 0.5 + segment.set_element_jump_vector(vector) return if segment.curve.point_count < 2: return + if segment.is_freehand(): + var index := -1 + if handle == RinkCanvas.Handle.START: + index = 0 + elif handle == RinkCanvas.Handle.END: + index = segment.curve.point_count - 1 + elif handle == RinkCanvas.Handle.FREEHAND_POINT: + index = detail + if index >= 0 and index < segment.curve.point_count: + segment.curve.set_point_position( + index, + _routine.rink.clamp_point(model_point) + ) + _update_duration(segment) + return + var start := segment.curve.get_point_position(0) var end := segment.curve.get_point_position(segment.curve.point_count - 1) @@ -2624,6 +3455,9 @@ func _apply_handle_drag( func _rebuild_segment(segment: PathSegment, start: Vector2, end: Vector2) -> void: + if segment.is_freehand(): + # Freehand endpoints are edited in place so the drawn shape survives. + return if segment.is_arc(): _set_arc_geometry( segment, @@ -2665,6 +3499,193 @@ func _create_segment( return segment +func _prepare_freehand_segment(segment: PathSegment, start: Vector2) -> void: + segment.template = PathSegment.Template.FREEHAND + var curve := segment.curve + curve.clear_points() + curve.add_point(_routine.rink.clamp_point(start)) + + +func _append_freehand_point(segment: PathSegment, model_point: Vector2) -> void: + if segment == null or segment.curve == null: + return + var point := _routine.rink.clamp_point(model_point) + var curve := segment.curve + if curve.point_count == 0: + curve.add_point(point) + return + if curve.point_count >= FREELINE_MAX_POINTS: + return + var last := curve.get_point_position(curve.point_count - 1) + var pixels_per_meter := maxf( + 1.0, + rink_canvas.get_view_transform().pixels_per_meter + ) + var min_distance := FREELINE_POINT_STEP_PX / pixels_per_meter + if last.distance_to(point) < min_distance: + return + curve.add_point(point) + + +func can_smooth_selected_freehand() -> bool: + if _selected_segment_ids.size() > 1: + return false + var segment := get_selected_segment() + return ( + segment != null + and segment.is_freehand() + and segment.curve != null + and segment.curve.point_count >= 3 + ) + + +## Softens the selected freehand polyline. Endpoints stay fixed; each press +## applies two Laplacian passes and is undoable. +func smooth_selected_freehand() -> bool: + if not can_smooth_selected_freehand(): + return false + var segment := get_selected_segment() + var point_count := segment.curve.point_count + _record_undo() + + var points := PackedVector2Array() + points.resize(point_count) + for index: int in range(point_count): + points[index] = segment.curve.get_point_position(index) + + var neighbor_weight := ( + (1.0 - FREELINE_SMOOTH_CENTER_WEIGHT) * 0.5 + ) + for iteration: int in range(FREELINE_SMOOTH_ITERATIONS): + var next := PackedVector2Array() + next.resize(point_count) + next[0] = points[0] + next[point_count - 1] = points[point_count - 1] + for index: int in range(1, point_count - 1): + next[index] = _routine.rink.clamp_point( + points[index] * FREELINE_SMOOTH_CENTER_WEIGHT + + (points[index - 1] + points[index + 1]) * neighbor_weight + ) + points = next + + for index: int in range(1, point_count - 1): + segment.curve.set_point_position(index, points[index]) + _update_duration(segment) + _mark_dirty() + rink_canvas.refresh() + _update_status() + return true + + +func can_simplify_selected_freehand() -> bool: + if _selected_segment_ids.size() > 1: + return false + var segment := get_selected_segment() + return ( + segment != null + and segment.is_freehand() + and segment.curve != null + and segment.curve.point_count > 2 + ) + + +## Reduces the selected freehand to the points needed for its shape. The +## tolerance follows the current zoom (about one screen pixel). +func simplify_selected_freehand() -> bool: + if not can_simplify_selected_freehand(): + return false + var segment := get_selected_segment() + return _simplify_freehand_segment( + segment, + _freehand_simplify_tolerance_m(), + true + ) + + +func _freehand_simplify_tolerance_m() -> float: + var pixels_per_meter := maxf( + 1.0, + rink_canvas.get_view_transform().pixels_per_meter + ) + return FREELINE_SIMPLIFY_TOLERANCE_PX / pixels_per_meter + + +func _simplify_freehand_segment( + segment: PathSegment, + tolerance_m: float, + record_undo: bool +) -> bool: + if segment == null or segment.curve == null: + return false + var point_count := segment.curve.point_count + if point_count <= 2: + return false + var points := PackedVector2Array() + points.resize(point_count) + for index: int in range(point_count): + points[index] = segment.curve.get_point_position(index) + var simplified := _rdp_simplify(points, tolerance_m) + if simplified.size() >= point_count or simplified.size() < 2: + return false + + if record_undo: + _record_undo() + segment.curve.clear_points() + for point: Vector2 in simplified: + segment.curve.add_point(point) + _update_duration(segment) + if record_undo: + _mark_dirty() + rink_canvas.refresh() + _update_status() + return true + + +## Iterative Ramer-Douglas-Peucker implementation. Keeping the endpoints is +## explicit, and the explicit stack avoids recursion depth limits on very long +## freehand strokes. +static func _rdp_simplify( + points: PackedVector2Array, + epsilon: float +) -> PackedVector2Array: + if points.size() <= 2 or epsilon <= 0.0: + return points + var keep := PackedByteArray() + keep.resize(points.size()) + keep[0] = 1 + keep[points.size() - 1] = 1 + var epsilon_squared := epsilon * epsilon + var stack: Array[Vector2i] = [Vector2i(0, points.size() - 1)] + while not stack.is_empty(): + var segment_range: Vector2i = stack.pop_back() + var start := segment_range.x + var end := segment_range.y + if end <= start + 1: + continue + var max_distance := -1.0 + var max_index := -1 + for index: int in range(start + 1, end): + var closest := Geometry2D.get_closest_point_to_segment( + points[index], + points[start], + points[end] + ) + var distance := points[index].distance_squared_to(closest) + if distance > max_distance: + max_distance = distance + max_index = index + if max_distance > epsilon_squared and max_index > start: + keep[max_index] = 1 + stack.append(Vector2i(start, max_index)) + stack.append(Vector2i(max_index, end)) + + var result := PackedVector2Array() + for index: int in range(points.size()): + if keep[index] != 0: + result.append(points[index]) + return result + + func _update_segment_geometry( segment: PathSegment, end: Vector2, @@ -2774,9 +3795,10 @@ func play() -> void: if _playback_time >= _playback_total_duration - 0.0001: _playback_time = 0.0 + _selected_segment_ids.clear() _selected_segment_id = "" rink_canvas.cancel_interaction() - rink_canvas.set_selected_segment("") + rink_canvas.set_selected_segments(PackedStringArray(), "") _playing = true _update_playback_state(0.0, true) _start_music() @@ -3009,15 +4031,47 @@ func _update_playback_state( if segment.direction == PathSegment.Direction.BACKWARD: facing = -facing + var marker_scale := 1.0 if segment.is_element_marker(): - # Markers have no tangent: keep facing the way the skater arrived. A - # spin rotates in place, so its heading follows the elapsed stand time. + # Markers have no tangent: keep facing the way the skater arrived. Spins + # and jumps rotate in place, so the heading follows the elapsed stand + # time. facing = _entry_arrival_heading(entry_index) + var progress := 0.0 + if duration > 0.0: + progress = clampf(local_time / duration, 0.0, 1.0) if segment.element_type == PathSegment.ElementType.SPIN: + var spin_rate := segment.get_spin_revolutions_per_second() + if spin_rate <= 0.0: + # Legacy files without a planned revolution count. + spin_rate = SPIN_REVOLUTIONS_PER_SECOND facing = facing.rotated( - TAU * SPIN_REVOLUTIONS_PER_SECOND * local_time + segment.get_rotation_sign() + * TAU + * spin_rate + * local_time ) _playback_heading = facing + elif segment.element_type == PathSegment.ElementType.JUMP: + # Jumps turn once per revolution in the air; the count is taken from + # the jump code (3Lz = 3, 2A = 2.5). The marker grows towards the + # middle of the air time and travels along the jump vector to the + # landing point. + var jump_vector := segment.element_jump_vector + if jump_vector.length_squared() <= 0.000001: + jump_vector = facing * segment.get_jump_distance_m() + var travel_heading := facing + if jump_vector.length_squared() > 0.000001: + travel_heading = jump_vector.normalized() + facing = travel_heading.rotated( + segment.get_rotation_sign() + * TAU + * segment.get_jump_revolutions() + * progress + ) + _playback_heading = facing + position += jump_vector * progress + marker_scale = 1.0 + 0.85 * sin(PI * progress) elif force_heading or _playback_heading.length_squared() <= 0.0: _playback_heading = facing elif force_heading or delta <= 0.0 or _playback_heading.length_squared() <= 0.0: @@ -3044,7 +4098,8 @@ func _update_playback_state( _playback_heading, section_id, segment.edge, - segment.direction + segment.direction, + marker_scale ) if _view_3d_active and _presentation_3d != null: _presentation_3d.update_pose( @@ -3106,7 +4161,8 @@ func _update_playback_ui() -> void: func _update_play_button() -> void: - play_button.text = "Pause" if _playing else "Start" + play_button.text = "" + play_button.icon = PLAYBACK_PAUSE_ICON if _playing else PLAYBACK_PLAY_ICON play_button.tooltip_text = "Pause" if _playing else "Abspielen" @@ -3198,12 +4254,16 @@ func _refresh_timeline_labels() -> void: for section: RoutineSection in _routine.sections: if section == null: continue + var group_starts: Dictionary[String, ResolvedElement] = {} + for element: ResolvedElement in section.get_elements(): + if not element.segments.is_empty(): + group_starts[element.segments[0].segment_id] = element for segment: PathSegment in section.segments: if segment == null: continue var text := segment.label.strip_edges() - if text.is_empty() and segment.is_element(): - text = segment.get_element_caption().strip_edges() + if text.is_empty() and group_starts.has(segment.segment_id): + text = group_starts[segment.segment_id].get_caption().strip_edges() if not text.is_empty(): element_labels.append({ "time_seconds": total, @@ -3528,6 +4588,9 @@ func open_3d_view() -> void: return _view_3d_active = true + _multi_select_enabled = false + multi_select_button.set_pressed_no_signal(false) + rink_canvas.set_multi_select_enabled(false) _presentation_3d.setup(_routine) if _playback_entries.is_empty(): @@ -3632,8 +4695,7 @@ func _set_2d_controls_visible(visible: bool) -> void: delete_segment_button.visible = visible var controls: Array[Control] = [ - tool_label, - tool_option, + tool_buttons_container, forward_button, backward_button, inside_button, @@ -3702,19 +4764,27 @@ func _set_timing_details_visible(visible: bool) -> void: func _set_timing_controls_enabled(enabled: bool) -> void: - label_button.disabled = not enabled - element_button.disabled = not enabled - duration_minus_button.disabled = not enabled - duration_plus_button.disabled = not enabled - speed_minus_button.disabled = not enabled - speed_plus_button.disabled = not enabled - calibrate_button.disabled = not enabled - reset_timing_button.disabled = not enabled - profile_option.disabled = not enabled + var editable := enabled and _selected_segment_ids.size() <= 1 + label_button.disabled = not editable + element_button.disabled = not editable + element_type_option.disabled = not editable + duration_minus_button.disabled = not editable + duration_plus_button.disabled = not editable + speed_minus_button.disabled = not editable + speed_plus_button.disabled = not editable + calibrate_button.disabled = not editable + reset_timing_button.disabled = not editable + profile_option.disabled = not editable func _update_timing_ui() -> void: var selected := get_selected_segment() + var can_smooth := can_smooth_selected_freehand() + smooth_button.visible = can_smooth + smooth_button.disabled = not can_smooth + var can_simplify := can_simplify_selected_freehand() + simplify_button.visible = can_simplify + simplify_button.disabled = not can_simplify _set_timing_details_visible( _tool != Tool.ELEMENT and (selected == null or not selected.is_element_marker()) @@ -3758,17 +4828,25 @@ func _update_timing_ui() -> void: profile_option.disabled = true return + var timing_element := get_selected_element() + var timing_lead := timing_element.get_lead() if timing_element != null else selected element_button.tooltip_text = ( - "Element bearbeiten: %s" % selected.get_element_caption() - if selected.is_element() + "Element bearbeiten: %s" % timing_lead.get_element_caption() + if timing_lead != null and timing_lead.is_element() else "Element für das ausgewählte Segment" ) var kind := "Bogen" if selected.is_arc() else "Linie" - if selected.is_element(): + if selected.is_freehand(): + kind = "Freeline" + if timing_lead != null and timing_lead.is_element(): kind = "%s · %s" % [ - PathSegment.element_type_name(selected.element_type), - selected.get_element_caption(), + PathSegment.element_type_name(timing_lead.element_type), + timing_lead.get_element_caption(), ] + if timing_element != null and timing_element.segments.size() > 1: + kind += " · %d Teile" % timing_element.segments.size() + elif timing_element != null and timing_element.is_sequence_range(): + kind += " · 1 Teil" timing_selection_label.text = "%s · %s m" % [ kind, _format_decimal(selected.get_length_m()), @@ -3958,6 +5036,8 @@ func _install_routine( ) -> void: if _view_3d_active: close_3d_view() + _sequence_mode = false + _open_sequence_id = "" _playing = false _playback_time = 0.0 _playback_section_id = "" @@ -4001,12 +5081,17 @@ func _install_routine( if found != null: _active_section = found + _selected_segment_ids.clear() _selected_segment_id = "" + _multi_select_enabled = false + multi_select_button.set_pressed_no_signal(false) + rink_canvas.set_multi_select_enabled(false) _current_segment = null _rebuild_counters_from_ids() + _update_tool_buttons() rink_canvas.set_routine(_routine, refit) - rink_canvas.set_selected_segment("") + rink_canvas.set_selected_segments(PackedStringArray(), "") rink_canvas.set_active_section(_active_section.section_id) _rebuild_section_list() _update_status() @@ -4040,14 +5125,18 @@ func _migrate_routine(routine: Routine) -> void: func _rebuild_counters_from_ids() -> void: var section_ids: Array[String] = [] var segment_ids: Array[String] = [] + var element_group_ids: Array[String] = [] for section: RoutineSection in _routine.sections: section_ids.append(section.section_id) for segment: PathSegment in section.segments: if segment != null: segment_ids.append(segment.segment_id) + if not segment.element_group_id.is_empty(): + element_group_ids.append(segment.element_group_id) _section_counter = maxi(1, _max_numeric_suffix("section-", section_ids)) _segment_counter = _max_numeric_suffix("seg-", segment_ids) + _element_group_counter = _max_numeric_suffix("el-", element_group_ids) func _max_numeric_suffix(prefix: String, ids: Array[String]) -> int: @@ -4270,6 +5359,18 @@ func _setup_export_controls() -> void: export_scope_option.select(0) +func _maximize_window_on_desktop() -> void: + # Desktop builds start maximized. Mobile and web keep the window shape the + # OS or browser provides, and headless test runs have no real window. + if not OS.has_feature("pc") or DisplayServer.get_name() == "headless": + return + var window := get_window() + if window == null: + return + if window.mode != Window.MODE_MAXIMIZED: + window.mode = Window.MODE_MAXIMIZED + + func _apply_display_scale() -> void: var window := get_window() if window == null: @@ -4284,26 +5385,33 @@ func _apply_display_scale() -> void: func _apply_responsive_layout() -> void: - if title_label == null or tool_label == null: + if title_label == null: return _apply_display_scale() var compact := size.x < COMPACT_LAYOUT_WIDTH title_label.visible = not compact - tool_label.visible = not compact and not _view_3d_active timing_title.visible = not compact sections_panel.custom_minimum_size.x = 260.0 if compact else 300.0 undo_button.text = "Undo" if compact else "Rückgängig" redo_button.text = "Redo" if compact else "Wiederholen" - undo_button.custom_minimum_size.x = 72.0 if compact else 100.0 - redo_button.custom_minimum_size.x = 72.0 if compact else 110.0 + undo_button.custom_minimum_size.x = 68.0 if compact else 96.0 + redo_button.custom_minimum_size.x = 68.0 if compact else 106.0 + forward_button.text = "Vor" if compact else "Vorwärts" + backward_button.text = "Rück" if compact else "Rückwärts" + forward_button.custom_minimum_size.x = 54.0 if compact else 88.0 + backward_button.custom_minimum_size.x = 54.0 if compact else 92.0 + file_menu_button.custom_minimum_size.x = 54.0 if compact else 64.0 + inside_button.custom_minimum_size.x = 56.0 if compact else 64.0 + outside_button.custom_minimum_size.x = 56.0 if compact else 64.0 fit_button.text = "Fit" if compact else "Einpassen" - fit_button.custom_minimum_size.x = 56.0 if compact else 96.0 - view_3d_button.custom_minimum_size.x = 56.0 if compact else 64.0 + fit_button.custom_minimum_size.x = 56.0 if compact else 90.0 + view_3d_button.custom_minimum_size.x = 56.0 view_3d_separator.visible = not compact or _view_3d_active - tool_option.custom_minimum_size.x = 150.0 if compact else 170.0 + for button: Button in tool_buttons: + button.custom_minimum_size.x = 36.0 if compact else 44.0 calibrate_button.text = "Kalib." if compact else "Kalibrieren" calibrate_button.custom_minimum_size.x = 80.0 if compact else 100.0 timing_selection_label.custom_minimum_size.x = 120.0 if compact else 170.0 @@ -5252,14 +6360,11 @@ func _sync_toolbar_to_selection() -> void: _edge = selected.edge _update_direction_buttons() _update_edge_buttons() - if selected.is_element(): - _element_type = selected.element_type - _element_level = selected.element_level - var index := element_type_option.get_item_index(selected.element_type) - if index >= 0: - element_type_option.set_block_signals(true) - element_type_option.select(index) - element_type_option.set_block_signals(false) + var element := get_selected_element() + var element_segment := element.get_lead() if element != null else selected + if element_segment != null and element_segment.is_element(): + _element_level = element_segment.element_level + set_element_type(element_segment.element_type) func _update_direction_buttons() -> void: @@ -5282,6 +6387,7 @@ func _update_status() -> void: _refresh_playback_timeline() _update_timing_ui() + _update_group_sequence_buttons() var segment_count := _active_section.segments.size() var segment_word := "Segment" if segment_count == 1 else "Segmente" @@ -5316,15 +6422,49 @@ func _update_status() -> void: ) var selected := get_selected_segment() - delete_segment_button.disabled = selected == null + delete_segment_button.disabled = ( + selected == null or _selected_segment_ids.size() > 1 + ) if selected != null: + if _selected_segment_ids.size() > 1: + text += " | %d Segmente ausgewählt" % _selected_segment_ids.size() + var selected_element := get_selected_element() + if selected_element != null and selected_element.is_sequence_range(): + var part_count := selected_element.segments.size() + text += " | Sequenz: %s · %d %s" % [ + selected_element.get_caption(), + part_count, + "Teil" if part_count == 1 else "Teile", + ] if selected.is_element_marker(): text += " | Auswahl: %s · %s · %s s" % [ PathSegment.element_type_name(selected.element_type), selected.get_element_caption(), _format_seconds(selected.element_duration_seconds), ] + if selected.element_type == PathSegment.ElementType.SPIN: + var revolutions := selected.element_revolutions + if revolutions <= 0.0: + revolutions = _default_spin_revolutions( + selected.element_duration_seconds + ) + var spin_rate := selected.get_spin_revolutions_per_second() + if spin_rate <= 0.0: + spin_rate = SPIN_REVOLUTIONS_PER_SECOND + if revolutions > 0.0: + text += " · %d U (%s U/s)" % [ + roundi(revolutions), + _format_decimal(spin_rate), + ] + text += " · %s" % PathSegment.rotation_direction_name( + selected.element_rotation_direction + ) + elif selected.element_type == PathSegment.ElementType.JUMP: + text += " · %s m · %s U" % [ + _format_decimal(selected.get_jump_distance_m()), + _format_decimal(selected.get_jump_revolutions()), + ] status_label.text = text return @@ -5345,6 +6485,8 @@ func _update_status() -> void: side, roundi(selected.arc_depth_ratio * 100.0), ] + elif selected.is_freehand(): + kind = "Freeline" text += " | Auswahl: %s · %s · %s" % [ kind, direction_word, @@ -5353,12 +6495,28 @@ func _update_status() -> void: var segment_label := selected.label.strip_edges() if not segment_label.is_empty(): text += ' · „%s“' % segment_label + if selected.is_freehand(): + text += " · Punkte ziehen zum Formen" status_label.text = text return var hint := "Links ziehen: zeichnen · Mitte/2 Finger: pan · Rad/Pinch: zoom" - if _tool == Tool.SELECT: - hint = "Tippen: auswählen · Griffe/Buttons: bearbeiten · leere Fläche: pan" + if _sequence_mode: + hint = "Sequenz aktiv: zeichnen fügt Teilstrecken hinzu · Sequenz-Button: abschließen" + elif _tool == Tool.SELECT: + hint = ( + "Mehrfachauswahl: Segmente antippen · leere Fläche: pan · Esc: beenden" + if _multi_select_enabled + else "Tippen: auswählen · Shift/Mehrfach: mehrere · leere Fläche: pan" + ) + elif _tool == Tool.FREELINE: + hint = "Ziehen: Freeline frei zeichnen · Ende: Segment abschließen" elif _tool == Tool.ELEMENT: - hint = "Tippen: Element setzen · Element-Button: Typ, Kürzel, Level" + match _element_type: + PathSegment.ElementType.SPIN: + hint = "Tippen: Pirouette setzen · Element-Button: Kürzel, Level, Umdrehungen" + PathSegment.ElementType.SEQUENCE: + hint = "Tippen: Sequenz setzen · Element-Button: Kürzel, Level" + _: + hint = "Tippen: Sprung setzen · Element-Button: Kürzel, Kombination" status_label.text = "%s | %s" % [text, hint] diff --git a/rinkplanner/src/whiteboard/io/routine_pdf_exporter.gd b/rinkplanner/src/whiteboard/io/routine_pdf_exporter.gd index 05fcf9e..86df583 100644 --- a/rinkplanner/src/whiteboard/io/routine_pdf_exporter.gd +++ b/rinkplanner/src/whiteboard/io/routine_pdf_exporter.gd @@ -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, diff --git a/rinkplanner/src/whiteboard/io/svg_exporter.gd b/rinkplanner/src/whiteboard/io/svg_exporter.gd index 1ada561..5602d8f 100644 --- a/rinkplanner/src/whiteboard/io/svg_exporter.gd +++ b/rinkplanner/src/whiteboard/io/svg_exporter.gd @@ -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( - '%s' - % [_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( + '%s' + % [_n(point.x), _n(point.y), TEXT_COLOR, _escape(text)] + ) static func _sample_curve(curve: Curve2D) -> PackedVector2Array: diff --git a/rinkplanner/src/whiteboard/view/rink_canvas.gd b/rinkplanner/src/whiteboard/view/rink_canvas.gd index f0e4e74..f30e426 100644 --- a/rinkplanner/src/whiteboard/view/rink_canvas.gd +++ b/rinkplanner/src/whiteboard/view/rink_canvas.gd @@ -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)) diff --git a/rinkplanner/tests/run_adult_tests.gd b/rinkplanner/tests/run_adult_tests.gd index 5f1671b..ef25889 100644 --- a/rinkplanner/tests/run_adult_tests.gd +++ b/rinkplanner/tests/run_adult_tests.gd @@ -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] diff --git a/rinkplanner/tests/run_export_tests.gd b/rinkplanner/tests/run_export_tests.gd index 44be76d..4360e91 100644 --- a/rinkplanner/tests/run_export_tests.gd +++ b/rinkplanner/tests/run_export_tests.gd @@ -33,6 +33,10 @@ func _run() -> void: svg.contains(">3Lz & <Spin>"), "SVG contains and escapes segment labels" ) + _check( + _count(svg, ">3Lz & <Spin>") == 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 & " + 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" diff --git a/rinkplanner/tests/run_file_format_tests.gd b/rinkplanner/tests/run_file_format_tests.gd index 76766fc..bf808a0 100644 --- a/rinkplanner/tests/run_file_format_tests.gd +++ b/rinkplanner/tests/run_file_format_tests.gd @@ -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 diff --git a/rinkplanner/tests/run_model_tests.gd b/rinkplanner/tests/run_model_tests.gd index 254f01e..562d994 100644 --- a/rinkplanner/tests/run_model_tests.gd +++ b/rinkplanner/tests/run_model_tests.gd @@ -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() diff --git a/rinkplanner/tests/run_playback_tests.gd b/rinkplanner/tests/run_playback_tests.gd index 60d0823..1a8cc7f 100644 --- a/rinkplanner/tests/run_playback_tests.gd +++ b/rinkplanner/tests/run_playback_tests.gd @@ -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. diff --git a/rinkplanner/tests/run_touch_tests.gd b/rinkplanner/tests/run_touch_tests.gd index 67cfac2..ea38412 100644 --- a/rinkplanner/tests/run_touch_tests.gd +++ b/rinkplanner/tests/run_touch_tests.gd @@ -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( diff --git a/rinkplanner/tests/run_validation_tests.gd b/rinkplanner/tests/run_validation_tests.gd index d3227b4..aa800d7 100644 --- a/rinkplanner/tests/run_validation_tests.gd +++ b/rinkplanner/tests/run_validation_tests.gd @@ -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, diff --git a/rinkplanner/tests/run_whiteboard_tests.gd b/rinkplanner/tests/run_whiteboard_tests.gd index cdf5a47..eeffa72 100644 --- a/rinkplanner/tests/run_whiteboard_tests.gd +++ b/rinkplanner/tests/run_whiteboard_tests.gd @@ -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()