feat: add step-sequence groups, freehand editing and element PDF
- group contiguous path segments into one sequence element with shared group IDs - resolve elements centrally and score/adult-count groups once - add freehand tool with point editing, smoothing and RDP reduction - render one PDF table row and badge per element instead of per segment - turn playback start/pause/reset into icon buttons - add multi-select grouping and extend tests/documentation
This commit is contained in:
parent
e9d520459e
commit
55e7b163b5
33 changed files with 4623 additions and 345 deletions
|
|
@ -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
|
||||
|
|
|
|||
61
docs/findings-2026-11-10-freeline.md
Normal file
61
docs/findings-2026-11-10-freeline.md
Normal file
|
|
@ -0,0 +1,61 @@
|
|||
# Findings – Freeline-Werkzeug (2026-11-10)
|
||||
|
||||
## Ergebnis
|
||||
|
||||
Die Werkzeugleiste hat ein neues **Freeline**-Werkzeug. Es zeichnet den
|
||||
Laufweg frei mit Maus oder Finger und speichert ihn als mehrpunktige Kurve.
|
||||
Das Icon ist eine gekräuselte Linie mit Stift (`assets/icons/tools/freeline.svg`).
|
||||
|
||||
| Ziel | Ergebnis |
|
||||
| :--- | :--- |
|
||||
| Werkzeug | `Tool.FREELINE` zwischen den Bögen und den Element-Werkzeugen |
|
||||
| Modell | `PathSegment.Template.FREEHAND` + mehrpunktige `Curve2D` |
|
||||
| Sampling | ca. 2,5 px Punktabstand, max. 4.000 Punkte pro Segment |
|
||||
| Bearbeitung | Start-/Endgriff verschieben den jeweiligen Endpunkt, ohne die Kurve zu kollabieren |
|
||||
| Wiedergabe | Playback, 3D, SVG und PDF nutzen dieselbe Kurve wie Linie/Bogen |
|
||||
| Persistenz | Schema 6, Vorlagenwert `freehand` |
|
||||
| Tests | `./tools/test.sh` grün |
|
||||
|
||||
## Modell und Zeichnen
|
||||
|
||||
- Beim Start legt der Controller ein Segment mit einem Startpunkt an.
|
||||
- Jede Bewegung wird in Rink-Koordinaten geklemmt und nur übernommen, wenn sie
|
||||
weit genug vom letzten Punkt entfernt ist. Der Abstand orientiert sich mit
|
||||
`FREELINE_POINT_STEP_PX` an der aktuellen Zoomstufe.
|
||||
- Bei `draw_finished` wird der letzte Punkt ergänzt und die Dauer aus Länge und
|
||||
Timing-Profil aktualisiert. Zu kurze Striche werden wie bei Linie/Bogen
|
||||
verworfen.
|
||||
- Start- und Endgriff bearbeiten bei `Template.FREEHAND` den ersten bzw.
|
||||
letzten Kurvenpunkt direkt. Zusätzlich zeigt der Canvas bis zu 64
|
||||
gleichmäßig verteilte Zwischenpunkte als kleine Griffe. Ein Drag bewegt den
|
||||
jeweiligen Kurvenpunkt über einen Detail-Index im Handle-Signal; alle
|
||||
anderen Punkte bleiben erhalten. Es gibt keinen Bogen-Griff.
|
||||
- **Glätten:** Der Timing-Button führt zwei Laplacian-Durchgänge auf den
|
||||
Innenpunkten aus. Start/Ende bleiben fest, die Punktanzahl bleibt gleich,
|
||||
Länge/Dauer werden neu berechnet und jeder Druck ist undo-fähig.
|
||||
- **Punktreduktion:** Eine iterative RDP-Reduktion läuft beim Abschluss einer
|
||||
Freeline automatisch (ca. 1 px Toleranz, in Meter umgerechnet) und über den
|
||||
Button „Vereinfachen“ für bestehende Segmente. Endpunkte bleiben erhalten;
|
||||
die Aktion ist undo-fähig.
|
||||
- Freeline-Segmente sind normale Pfadsegmente: Richtung, Kante, Label, Timing,
|
||||
Löschen, Undo/Redo, Multi-Auswahl und Sequenzgruppierung funktionieren wie
|
||||
bei Linie/Bogen.
|
||||
|
||||
## Oberfläche
|
||||
|
||||
- Neuer Toolbar-Button mit Tooltip „Freeline“. Im kompakten 1024-px-Layout
|
||||
wurden die übrigen Topbar-Mindestbreiten leicht reduziert, damit die Leiste
|
||||
weiterhin ohne Umbruch passt.
|
||||
- Statusleiste zeigt „Freeline“ als Auswahlart und den Zeichenhinweis.
|
||||
- Das Icon verwendet denselben weißen Strich wie die vorhandenen Werkzeuge.
|
||||
|
||||
## Offene Punkte
|
||||
|
||||
1. **Toleranz:** Die RDP-Reduktion nutzt einen konservativen Startwert von
|
||||
etwa einem Bildschirmpixel. Eine einstellbare Stärke (z. B. für besonders
|
||||
detailreiche Zeichnungen) ist noch offen.
|
||||
2. **Sehr feine Kurven:** Bei mehr als 64 Punkten zeigt der Editor nur eine
|
||||
gleichmäßige Auswahl als Griffe; nicht sichtbare Zwischenpunkte lassen
|
||||
sich nicht direkt greifen.
|
||||
3. **Druck/Export:** SVG/PDF übernehmen die Kurve; eine gesonderte
|
||||
Freeline-Legende gibt es nicht.
|
||||
62
docs/findings-2026-11-10-step-sequence-gruppen.md
Normal file
62
docs/findings-2026-11-10-step-sequence-gruppen.md
Normal file
|
|
@ -0,0 +1,62 @@
|
|||
# Findings – Step Sequences als Elementgruppe (2026-11-10)
|
||||
|
||||
## Ergebnis
|
||||
|
||||
Schrittsequenzen können jetzt als **ein** Element über mehrere gezeichnete
|
||||
Teilstrecken laufen. Das ist Option A aus dem Modell-Brainstorm: Die
|
||||
Elementdaten bleiben am Lead-Segment, die Mitglieder verweisen über eine
|
||||
gemeinsame `element_group_id` darauf.
|
||||
|
||||
| Ziel | Ergebnis |
|
||||
| :--- | :--- |
|
||||
| Modell | `PathSegment.element_group_id`; Lead trägt Typ, Kürzel, Level, Features |
|
||||
| Auflösung | `RoutineSection.get_elements()` liefert `ResolvedElement`-Sichten |
|
||||
| Wertung | Validator, Adult-Regeln und Basiswert zählen eine Gruppe einmal |
|
||||
| Darstellung | ein Label pro Gruppe am Gruppenmittelpunkt (Canvas und SVG) |
|
||||
| PDF | eine Tabellenzeile und ein Rink-Badge pro Element, nicht pro Segment |
|
||||
| Bedienung | Sequenz-Zeichenmodus und nachträgliches Gruppieren per Mehrfachauswahl |
|
||||
| Persistenz | Schema 5, additives `element_group_id` |
|
||||
| Tests | `./tools/test.sh` grün |
|
||||
|
||||
## Modell
|
||||
|
||||
- `element_group_id` ist auf allen Mitgliedern gleich. Genau ein Segment ist
|
||||
Lead (`element_type != NONE`); die übrigen sind normale Pfadsegmente ohne
|
||||
Elementdaten.
|
||||
- Gruppen sind zusammenhängend und liegen in einer Section. Mehrere Leads,
|
||||
Lücken, Null-Längen-Mitglieder und Nicht-Sequenz-Typen werden abgelehnt.
|
||||
- `ResolvedElement` kapselt Lead, Mitglieder, Dauer, Caption, Länge und den
|
||||
Mittelpunkt der Gruppe. Die Sicht ist ephemär; ein erneutes Auflösen liefert
|
||||
ein neues Objekt mit derselben `element_id`.
|
||||
- Alte Dateien ohne Gruppen-ID bleiben gültig: Jedes getaggte Segment ist ein
|
||||
Einzelelement. Schema 4 → 5 ist rein additiv.
|
||||
|
||||
## Bedienung
|
||||
|
||||
- Das Sequenz-Symbol startet den Zeichenmodus. Linie/Bogen/Freeline zeichnen
|
||||
die Teilstrecken; die erste wird Lead. Erneutes Drücken, Esc oder ein
|
||||
anderes Werkzeug beendet den Bereich.
|
||||
- Eine bestehende Sequenz am Abschnittsende lässt sich fortsetzen: Mitglied
|
||||
auswählen, Sequenz-Symbol drücken, weiterzeichnen.
|
||||
- Ein beliebiges Mitglied öffnet im Element-Dialog immer die Gruppe.
|
||||
- Lead löschen: Das nächste Mitglied übernimmt die Elementdaten.
|
||||
- „Kein Element“ löst die Gruppe auf; die Pfadsegmente bleiben erhalten.
|
||||
- Neue Bereiche starten mit `StSq` und Level Base.
|
||||
- **Mehrfachauswahl:** Der Knopf im Abschnittsbereich schaltet auf
|
||||
addierendes Antippen; auf dem Desktop geht auch Shift/Cmd/Ctrl-Klick.
|
||||
„Sequenz gruppieren (N)“ fasst eine zusammenhängende Auswahl in einem
|
||||
Undo-Schritt zusammen. Lücken, Marker und bestehende Elemente blockieren
|
||||
die Aktion.
|
||||
|
||||
## Offene Punkte
|
||||
|
||||
1. **Teilen/Zusammenführen:** Eine Gruppe kann derzeit nur über Löschen oder
|
||||
„Kein Element“ verändert werden; ein explizites Teilen fehlt.
|
||||
2. **Gruppen-Hervorhebung:** Der Canvas markiert beim Auswählen nur das
|
||||
gewählte Segment, nicht die gesamte Gruppe.
|
||||
3. **Einzelne Sequenz-Tags zusammenführen:** Bereits separat getaggte
|
||||
Sequenzen müssen vor dem Gruppieren über „Kein Element“ gelöst werden;
|
||||
ein automatisches Zusammenführen mit Metadaten-Konfliktlösung fehlt.
|
||||
4. **Punktmarker:** Sprung/Pirouette bleiben Einzelelemente mit einem
|
||||
Ankersegment. Eine vollständige `RoutineElement`-Ablage (Option B) ist
|
||||
weiterhin der langfristige Umbau.
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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)
|
||||
|
|
|
|||
4
rinkplanner/assets/icons/playback/pause.svg
Normal file
4
rinkplanner/assets/icons/playback/pause.svg
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32">
|
||||
<rect x="9.5" y="7" width="4.5" height="18" rx="1.5" fill="#ffffff"/>
|
||||
<rect x="18" y="7" width="4.5" height="18" rx="1.5" fill="#ffffff"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 234 B |
43
rinkplanner/assets/icons/playback/pause.svg.import
Normal file
43
rinkplanner/assets/icons/playback/pause.svg.import
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
[remap]
|
||||
|
||||
importer="texture"
|
||||
type="CompressedTexture2D"
|
||||
uid="uid://b5s4e4aaexpoh"
|
||||
path="res://.godot/imported/pause.svg-8ec77cf881d30ecb6b3297b5f2a9e323.ctex"
|
||||
metadata={
|
||||
"vram_texture": false
|
||||
}
|
||||
|
||||
[deps]
|
||||
|
||||
source_file="res://assets/icons/playback/pause.svg"
|
||||
dest_files=["res://.godot/imported/pause.svg-8ec77cf881d30ecb6b3297b5f2a9e323.ctex"]
|
||||
|
||||
[params]
|
||||
|
||||
compress/mode=0
|
||||
compress/high_quality=false
|
||||
compress/lossy_quality=0.7
|
||||
compress/uastc_level=0
|
||||
compress/rdo_quality_loss=0.0
|
||||
compress/hdr_compression=1
|
||||
compress/normal_map=0
|
||||
compress/channel_pack=0
|
||||
mipmaps/generate=false
|
||||
mipmaps/limit=-1
|
||||
roughness/mode=0
|
||||
roughness/src_normal=""
|
||||
process/channel_remap/red=0
|
||||
process/channel_remap/green=1
|
||||
process/channel_remap/blue=2
|
||||
process/channel_remap/alpha=3
|
||||
process/fix_alpha_border=true
|
||||
process/premult_alpha=false
|
||||
process/normal_map_invert_y=false
|
||||
process/hdr_as_srgb=false
|
||||
process/hdr_clamp_exposure=false
|
||||
process/size_limit=0
|
||||
detect_3d/compress_to=1
|
||||
svg/scale=1.0
|
||||
editor/scale_with_editor_scale=false
|
||||
editor/convert_colors_with_editor_theme=false
|
||||
4
rinkplanner/assets/icons/playback/play.svg
Normal file
4
rinkplanner/assets/icons/playback/play.svg
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32">
|
||||
<path d="M11 7 L26 16 L11 25 Z" fill="#ffffff" stroke="#ffffff" stroke-width="2"
|
||||
stroke-linejoin="round"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 208 B |
43
rinkplanner/assets/icons/playback/play.svg.import
Normal file
43
rinkplanner/assets/icons/playback/play.svg.import
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
[remap]
|
||||
|
||||
importer="texture"
|
||||
type="CompressedTexture2D"
|
||||
uid="uid://dgw8yy1gph7sm"
|
||||
path="res://.godot/imported/play.svg-c3fcc450e86ff851f726127b32d4ae01.ctex"
|
||||
metadata={
|
||||
"vram_texture": false
|
||||
}
|
||||
|
||||
[deps]
|
||||
|
||||
source_file="res://assets/icons/playback/play.svg"
|
||||
dest_files=["res://.godot/imported/play.svg-c3fcc450e86ff851f726127b32d4ae01.ctex"]
|
||||
|
||||
[params]
|
||||
|
||||
compress/mode=0
|
||||
compress/high_quality=false
|
||||
compress/lossy_quality=0.7
|
||||
compress/uastc_level=0
|
||||
compress/rdo_quality_loss=0.0
|
||||
compress/hdr_compression=1
|
||||
compress/normal_map=0
|
||||
compress/channel_pack=0
|
||||
mipmaps/generate=false
|
||||
mipmaps/limit=-1
|
||||
roughness/mode=0
|
||||
roughness/src_normal=""
|
||||
process/channel_remap/red=0
|
||||
process/channel_remap/green=1
|
||||
process/channel_remap/blue=2
|
||||
process/channel_remap/alpha=3
|
||||
process/fix_alpha_border=true
|
||||
process/premult_alpha=false
|
||||
process/normal_map_invert_y=false
|
||||
process/hdr_as_srgb=false
|
||||
process/hdr_clamp_exposure=false
|
||||
process/size_limit=0
|
||||
detect_3d/compress_to=1
|
||||
svg/scale=1.0
|
||||
editor/scale_with_editor_scale=false
|
||||
editor/convert_colors_with_editor_theme=false
|
||||
5
rinkplanner/assets/icons/playback/reset.svg
Normal file
5
rinkplanner/assets/icons/playback/reset.svg
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32">
|
||||
<rect x="7.5" y="7" width="3" height="18" rx="1.5" fill="#ffffff"/>
|
||||
<path d="M26 7 L12 16 L26 25 Z" fill="#ffffff" stroke="#ffffff" stroke-width="2"
|
||||
stroke-linejoin="round"/>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 278 B |
43
rinkplanner/assets/icons/playback/reset.svg.import
Normal file
43
rinkplanner/assets/icons/playback/reset.svg.import
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
[remap]
|
||||
|
||||
importer="texture"
|
||||
type="CompressedTexture2D"
|
||||
uid="uid://jxlloyygkaxf"
|
||||
path="res://.godot/imported/reset.svg-8e97fcb27c41573005b052e1d23da329.ctex"
|
||||
metadata={
|
||||
"vram_texture": false
|
||||
}
|
||||
|
||||
[deps]
|
||||
|
||||
source_file="res://assets/icons/playback/reset.svg"
|
||||
dest_files=["res://.godot/imported/reset.svg-8e97fcb27c41573005b052e1d23da329.ctex"]
|
||||
|
||||
[params]
|
||||
|
||||
compress/mode=0
|
||||
compress/high_quality=false
|
||||
compress/lossy_quality=0.7
|
||||
compress/uastc_level=0
|
||||
compress/rdo_quality_loss=0.0
|
||||
compress/hdr_compression=1
|
||||
compress/normal_map=0
|
||||
compress/channel_pack=0
|
||||
mipmaps/generate=false
|
||||
mipmaps/limit=-1
|
||||
roughness/mode=0
|
||||
roughness/src_normal=""
|
||||
process/channel_remap/red=0
|
||||
process/channel_remap/green=1
|
||||
process/channel_remap/blue=2
|
||||
process/channel_remap/alpha=3
|
||||
process/fix_alpha_border=true
|
||||
process/premult_alpha=false
|
||||
process/normal_map_invert_y=false
|
||||
process/hdr_as_srgb=false
|
||||
process/hdr_clamp_exposure=false
|
||||
process/size_limit=0
|
||||
detect_3d/compress_to=1
|
||||
svg/scale=1.0
|
||||
editor/scale_with_editor_scale=false
|
||||
editor/convert_colors_with_editor_theme=false
|
||||
8
rinkplanner/assets/icons/tools/freeline.svg
Normal file
8
rinkplanner/assets/icons/tools/freeline.svg
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64" viewBox="0 0 32 32">
|
||||
<path d="M5 26 C 9 20, 3 16, 8 12 C 13 8, 18 13, 13 17 C 8 21, 17 23, 22 15"
|
||||
fill="none" stroke="#ffffff" stroke-width="2.4" stroke-linecap="round"/>
|
||||
<g fill="none" stroke="#ffffff" stroke-width="2.2" stroke-linecap="round" stroke-linejoin="round">
|
||||
<path d="M22 13 L27 8 L29.5 10.5 L24.5 15.5 Z"/>
|
||||
<path d="M22 13 L20.5 17 L24.5 15.5 Z" fill="#ffffff"/>
|
||||
</g>
|
||||
</svg>
|
||||
|
After Width: | Height: | Size: 472 B |
43
rinkplanner/assets/icons/tools/freeline.svg.import
Normal file
43
rinkplanner/assets/icons/tools/freeline.svg.import
Normal file
|
|
@ -0,0 +1,43 @@
|
|||
[remap]
|
||||
|
||||
importer="texture"
|
||||
type="CompressedTexture2D"
|
||||
uid="uid://m8rplqcxrmfj"
|
||||
path="res://.godot/imported/freeline.svg-f278063a2344cce1155c320e4d6b13a9.ctex"
|
||||
metadata={
|
||||
"vram_texture": false
|
||||
}
|
||||
|
||||
[deps]
|
||||
|
||||
source_file="res://assets/icons/tools/freeline.svg"
|
||||
dest_files=["res://.godot/imported/freeline.svg-f278063a2344cce1155c320e4d6b13a9.ctex"]
|
||||
|
||||
[params]
|
||||
|
||||
compress/mode=0
|
||||
compress/high_quality=false
|
||||
compress/lossy_quality=0.7
|
||||
compress/uastc_level=0
|
||||
compress/rdo_quality_loss=0.0
|
||||
compress/hdr_compression=1
|
||||
compress/normal_map=0
|
||||
compress/channel_pack=0
|
||||
mipmaps/generate=false
|
||||
mipmaps/limit=-1
|
||||
roughness/mode=0
|
||||
roughness/src_normal=""
|
||||
process/channel_remap/red=0
|
||||
process/channel_remap/green=1
|
||||
process/channel_remap/blue=2
|
||||
process/channel_remap/alpha=3
|
||||
process/fix_alpha_border=true
|
||||
process/premult_alpha=false
|
||||
process/normal_map_invert_y=false
|
||||
process/hdr_as_srgb=false
|
||||
process/hdr_clamp_exposure=false
|
||||
process/size_limit=0
|
||||
detect_3d/compress_to=1
|
||||
svg/scale=1.0
|
||||
editor/scale_with_editor_scale=false
|
||||
editor/convert_colors_with_editor_theme=false
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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")
|
||||
|
|
|
|||
177
rinkplanner/src/core/model/resolved_element.gd
Normal file
177
rinkplanner/src/core/model/resolved_element.gd
Normal file
|
|
@ -0,0 +1,177 @@
|
|||
class_name ResolvedElement
|
||||
extends RefCounted
|
||||
|
||||
## Read-only view of one scoring element. Option A keeps the element data on a
|
||||
## lead [PathSegment]; the other segments only share [member
|
||||
## PathSegment.element_group_id]. Point elements are resolved as a group of one,
|
||||
## so callers do not need to special-case markers.
|
||||
|
||||
var element_id: String = ""
|
||||
var section_id: String = ""
|
||||
var segments: Array[PathSegment] = []
|
||||
|
||||
|
||||
func get_lead() -> PathSegment:
|
||||
for segment: PathSegment in segments:
|
||||
if segment != null and segment.is_element():
|
||||
return segment
|
||||
if segments.is_empty():
|
||||
return null
|
||||
return segments[0]
|
||||
|
||||
|
||||
func get_type() -> PathSegment.ElementType:
|
||||
var lead := get_lead()
|
||||
return lead.element_type if lead != null else PathSegment.ElementType.NONE
|
||||
|
||||
|
||||
func get_code() -> String:
|
||||
var lead := get_lead()
|
||||
return lead.element_code if lead != null else ""
|
||||
|
||||
|
||||
func get_level() -> int:
|
||||
var lead := get_lead()
|
||||
return lead.element_level if lead != null else 0
|
||||
|
||||
|
||||
func get_features() -> PackedStringArray:
|
||||
var lead := get_lead()
|
||||
return lead.element_features.duplicate() if lead != null else PackedStringArray()
|
||||
|
||||
|
||||
func get_caption() -> String:
|
||||
var lead := get_lead()
|
||||
return lead.get_element_caption() if lead != null else ""
|
||||
|
||||
|
||||
func is_point_marker() -> bool:
|
||||
return segments.size() == 1 and segments[0] != null and segments[0].is_element_marker()
|
||||
|
||||
|
||||
func is_sequence_range() -> bool:
|
||||
return not is_point_marker() and get_type() == PathSegment.ElementType.SEQUENCE
|
||||
|
||||
|
||||
## Time this element occupies on the timeline. Point elements use their stand
|
||||
## time, sequence ranges sum the duration of all member segments.
|
||||
func get_duration_seconds() -> float:
|
||||
var total := 0.0
|
||||
for segment: PathSegment in segments:
|
||||
if segment != null:
|
||||
total += segment.get_effective_duration_seconds()
|
||||
return total
|
||||
|
||||
|
||||
func get_length_m() -> float:
|
||||
var total := 0.0
|
||||
for segment: PathSegment in segments:
|
||||
if segment != null:
|
||||
total += segment.get_length_m()
|
||||
return total
|
||||
|
||||
|
||||
func is_group() -> bool:
|
||||
return (
|
||||
not segments.is_empty()
|
||||
and not segments[0].element_group_id.is_empty()
|
||||
)
|
||||
|
||||
|
||||
## Id shared by the group members. Empty for a standalone element.
|
||||
func get_group_id() -> String:
|
||||
if segments.is_empty():
|
||||
return ""
|
||||
return segments[0].element_group_id
|
||||
|
||||
|
||||
func get_segment_ids() -> PackedStringArray:
|
||||
var ids := PackedStringArray()
|
||||
for segment: PathSegment in segments:
|
||||
if segment != null:
|
||||
ids.append(segment.segment_id)
|
||||
return ids
|
||||
|
||||
|
||||
## Point halfway along the group path, used for one caption per sequence range.
|
||||
func get_midpoint() -> Vector2:
|
||||
var anchor := get_anchor()
|
||||
var point: Vector2 = anchor["point"]
|
||||
return point
|
||||
|
||||
|
||||
func get_midpoint_tangent() -> Vector2:
|
||||
var anchor := get_anchor()
|
||||
var tangent: Vector2 = anchor["tangent"]
|
||||
return tangent
|
||||
|
||||
|
||||
func get_anchor() -> Dictionary:
|
||||
var total := get_length_m()
|
||||
if total <= 0.0:
|
||||
var lead := get_lead()
|
||||
if lead != null and lead.curve != null and lead.curve.point_count > 0:
|
||||
return {
|
||||
"point": lead.curve.get_point_position(0),
|
||||
"tangent": Vector2.RIGHT,
|
||||
}
|
||||
return {"point": Vector2.ZERO, "tangent": Vector2.RIGHT}
|
||||
|
||||
var target := total * 0.5
|
||||
var covered := 0.0
|
||||
for segment: PathSegment in segments:
|
||||
if segment == null or segment.curve == null:
|
||||
continue
|
||||
var length := segment.get_length_m()
|
||||
if length <= 0.0:
|
||||
continue
|
||||
if target <= covered + length or segment == segments[segments.size() - 1]:
|
||||
var local := clampf(target - covered, 0.0, length)
|
||||
var point := segment.curve.sample_baked(local)
|
||||
var ahead := segment.curve.sample_baked(minf(length, local + 0.5))
|
||||
var tangent := ahead - point
|
||||
if tangent.length_squared() <= 0.0001:
|
||||
tangent = Vector2.RIGHT
|
||||
return {"point": point, "tangent": tangent.normalized()}
|
||||
covered += length
|
||||
|
||||
var lead := get_lead()
|
||||
if lead != null and lead.curve != null and lead.curve.point_count > 0:
|
||||
return {
|
||||
"point": lead.curve.get_point_position(0),
|
||||
"tangent": Vector2.RIGHT,
|
||||
}
|
||||
return {"point": Vector2.ZERO, "tangent": Vector2.RIGHT}
|
||||
|
||||
|
||||
func validate() -> PackedStringArray:
|
||||
var errors := PackedStringArray()
|
||||
if element_id.is_empty():
|
||||
errors.append("element_id must not be empty")
|
||||
if section_id.is_empty():
|
||||
errors.append("section_id must not be empty")
|
||||
if segments.is_empty():
|
||||
errors.append("element must contain at least one segment")
|
||||
return errors
|
||||
|
||||
var leads := 0
|
||||
for segment: PathSegment in segments:
|
||||
if segment == null:
|
||||
errors.append("element contains a null segment")
|
||||
continue
|
||||
if segment.is_element():
|
||||
leads += 1
|
||||
if is_group() and segment.element_group_id != element_id:
|
||||
errors.append(
|
||||
"segment '%s' does not belong to group '%s'"
|
||||
% [segment.segment_id, element_id]
|
||||
)
|
||||
if leads != 1:
|
||||
errors.append("element group must have exactly one lead segment")
|
||||
if segments.size() > 1 and get_type() != PathSegment.ElementType.SEQUENCE:
|
||||
errors.append("only sequence ranges may span multiple segments")
|
||||
return errors
|
||||
|
||||
|
||||
func is_valid() -> bool:
|
||||
return validate().is_empty()
|
||||
1
rinkplanner/src/core/model/resolved_element.gd.uid
Normal file
1
rinkplanner/src/core/model/resolved_element.gd.uid
Normal file
|
|
@ -0,0 +1 @@
|
|||
uid://d2v6mcdc3qa1x
|
||||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -50,8 +50,9 @@ func validate_report(routine: Routine) -> ValidationReport:
|
|||
if section == null:
|
||||
continue
|
||||
report.section_count += 1
|
||||
for segment: PathSegment in section.segments:
|
||||
if segment == null or not segment.is_element():
|
||||
for element: ResolvedElement in section.get_elements():
|
||||
var segment := element.get_lead()
|
||||
if segment == null:
|
||||
continue
|
||||
report.element_count += 1
|
||||
_validate_segment(segment, section.section_id, report)
|
||||
|
|
@ -121,8 +122,9 @@ func _validate_category(
|
|||
for section: RoutineSection in routine.sections:
|
||||
if section == null:
|
||||
continue
|
||||
for segment: PathSegment in section.segments:
|
||||
if segment == null or not segment.is_element():
|
||||
for element: ResolvedElement in section.get_elements():
|
||||
var segment := element.get_lead()
|
||||
if segment == null:
|
||||
continue
|
||||
var code := segment.element_code.strip_edges()
|
||||
var lower := code.to_lower()
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load diff
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -300,12 +300,46 @@ static func _add_segment_labels(
|
|||
scale: float,
|
||||
center: Vector2
|
||||
) -> void:
|
||||
var grouped_segments: Dictionary[String, bool] = {}
|
||||
for section: RoutineSection in sections:
|
||||
for element: ResolvedElement in section.get_elements():
|
||||
if element.is_point_marker():
|
||||
continue
|
||||
var lead := element.get_lead()
|
||||
if lead == null:
|
||||
continue
|
||||
var text := lead.label.strip_edges()
|
||||
if text.is_empty():
|
||||
text = element.get_caption().strip_edges()
|
||||
for segment: PathSegment in element.segments:
|
||||
if segment != null:
|
||||
grouped_segments[segment.segment_id] = true
|
||||
if text.is_empty():
|
||||
continue
|
||||
var anchor := element.get_anchor()
|
||||
var mid_model: Vector2 = anchor["point"]
|
||||
var tangent_model: Vector2 = anchor["tangent"]
|
||||
_add_segment_label_text(
|
||||
lines,
|
||||
text,
|
||||
mid_model,
|
||||
mid_model + tangent_model * 0.5,
|
||||
scale,
|
||||
center
|
||||
)
|
||||
|
||||
for section: RoutineSection in sections:
|
||||
for segment: PathSegment in section.segments:
|
||||
if segment == null or segment.curve == null:
|
||||
continue
|
||||
if segment.is_element_marker():
|
||||
continue
|
||||
if grouped_segments.has(segment.segment_id):
|
||||
if segment.label.strip_edges().is_empty():
|
||||
continue
|
||||
var group := section.get_element_for_segment(segment.segment_id)
|
||||
if group != null and group.get_lead() == segment:
|
||||
continue
|
||||
var text := segment.label.strip_edges()
|
||||
if text.is_empty() and segment.is_element():
|
||||
text = segment.get_element_caption()
|
||||
|
|
@ -318,15 +352,26 @@ static func _add_segment_labels(
|
|||
var ahead := segment.curve.sample_baked(
|
||||
minf(length, length * 0.5 + 0.5)
|
||||
)
|
||||
var tangent := ahead - mid
|
||||
if tangent.length_squared() < 0.0001:
|
||||
tangent = Vector2.RIGHT
|
||||
var normal := Vector2(-tangent.y, tangent.x).normalized()
|
||||
var point := center + mid * scale + normal * 15.0
|
||||
lines.append(
|
||||
'<text x="%s" y="%s" font-family="sans-serif" font-size="13" fill="%s" stroke="#ffffff" stroke-width="3.5" paint-order="stroke" text-anchor="middle">%s</text>'
|
||||
% [_n(point.x), _n(point.y), TEXT_COLOR, _escape(text)]
|
||||
)
|
||||
_add_segment_label_text(lines, text, mid, ahead, scale, center)
|
||||
|
||||
|
||||
static func _add_segment_label_text(
|
||||
lines: PackedStringArray,
|
||||
text: String,
|
||||
mid: Vector2,
|
||||
ahead: Vector2,
|
||||
scale: float,
|
||||
center: Vector2
|
||||
) -> void:
|
||||
var tangent := ahead - mid
|
||||
if tangent.length_squared() < 0.0001:
|
||||
tangent = Vector2.RIGHT
|
||||
var normal := Vector2(-tangent.y, tangent.x).normalized()
|
||||
var point := center + mid * scale + normal * 15.0
|
||||
lines.append(
|
||||
'<text x="%s" y="%s" font-family="sans-serif" font-size="13" fill="%s" stroke="#ffffff" stroke-width="3.5" paint-order="stroke" text-anchor="middle">%s</text>'
|
||||
% [_n(point.x), _n(point.y), TEXT_COLOR, _escape(text)]
|
||||
)
|
||||
|
||||
|
||||
static func _sample_curve(curve: Curve2D) -> PackedVector2Array:
|
||||
|
|
|
|||
|
|
@ -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))
|
||||
|
|
|
|||
|
|
@ -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]
|
||||
|
|
|
|||
|
|
@ -33,6 +33,10 @@ func _run() -> void:
|
|||
svg.contains(">3Lz & <Spin></text>"),
|
||||
"SVG contains and escapes segment labels"
|
||||
)
|
||||
_check(
|
||||
_count(svg, ">3Lz & <Spin></text>") == 1,
|
||||
"SVG draws a sequence group label only once"
|
||||
)
|
||||
_check(
|
||||
svg.contains('paint-order="stroke"'),
|
||||
"SVG labels get a white outline"
|
||||
|
|
@ -161,15 +165,19 @@ func _run() -> void:
|
|||
long_section.title = "Langer Abschnitt"
|
||||
long_section.sequence_order = 2
|
||||
for index: int in range(30):
|
||||
long_section.segments.append(
|
||||
_make_segment(
|
||||
"seg-long-%d" % index,
|
||||
Vector2(-20.0 + float(index) * 0.5, -10.0),
|
||||
Vector2(-19.5 + float(index) * 0.5, -10.0),
|
||||
PathSegment.Direction.FORWARD,
|
||||
PathSegment.Edge.OUTSIDE
|
||||
)
|
||||
var long_segment := _make_segment(
|
||||
"seg-long-%d" % index,
|
||||
Vector2(-20.0 + float(index) * 0.5, -10.0),
|
||||
Vector2(-19.5 + float(index) * 0.5, -10.0),
|
||||
PathSegment.Direction.FORWARD,
|
||||
PathSegment.Edge.OUTSIDE
|
||||
)
|
||||
long_segment.set_element(
|
||||
PathSegment.ElementType.SEQUENCE,
|
||||
"StSq",
|
||||
0
|
||||
)
|
||||
long_section.segments.append(long_segment)
|
||||
long_routine.sections.append(long_section)
|
||||
var long_pdf := RoutinePdfExporter.build(long_routine, "section-long")
|
||||
_check(
|
||||
|
|
@ -177,6 +185,8 @@ func _run() -> void:
|
|||
"long PDF section continues on a second page"
|
||||
)
|
||||
|
||||
_test_pdf_element_table()
|
||||
|
||||
var scene := WhiteboardScene.instantiate()
|
||||
var controller := scene as WhiteboardController
|
||||
if controller != null:
|
||||
|
|
@ -297,6 +307,60 @@ func _run() -> void:
|
|||
_finish()
|
||||
|
||||
|
||||
func _test_pdf_element_table() -> void:
|
||||
var routine := Routine.new()
|
||||
routine.routine_id = "pdf-element-table"
|
||||
routine.title = "PDF Elemente"
|
||||
routine.rink = RinkDimensions.new()
|
||||
var section := RoutineSection.new()
|
||||
section.section_id = "section-elements"
|
||||
section.title = "Sequenz"
|
||||
section.sequence_order = 0
|
||||
|
||||
var first := _make_segment(
|
||||
"seg-group-1",
|
||||
Vector2(-20.0, 0.0),
|
||||
Vector2(-10.0, 0.0),
|
||||
PathSegment.Direction.FORWARD,
|
||||
PathSegment.Edge.OUTSIDE
|
||||
)
|
||||
first.element_group_id = "el-001"
|
||||
first.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 1)
|
||||
first.label = "Gruppe"
|
||||
var second := _make_segment(
|
||||
"seg-group-2",
|
||||
Vector2(-10.0, 0.0),
|
||||
Vector2(0.0, 0.0),
|
||||
PathSegment.Direction.FORWARD,
|
||||
PathSegment.Edge.INSIDE
|
||||
)
|
||||
second.element_group_id = "el-001"
|
||||
var plain := _make_segment(
|
||||
"seg-plain",
|
||||
Vector2(0.0, 0.0),
|
||||
Vector2(10.0, 0.0),
|
||||
PathSegment.Direction.FORWARD,
|
||||
PathSegment.Edge.OUTSIDE
|
||||
)
|
||||
plain.label = "NurPfad"
|
||||
section.segments = [first, second, plain]
|
||||
routine.sections = [section]
|
||||
|
||||
var pdf := RoutinePdfExporter.build(routine, section.section_id)
|
||||
var text := pdf.get_string_from_ascii()
|
||||
_check(text.contains("Gruppe"), "PDF table contains the element label")
|
||||
_check(text.contains("StSq L1"), "PDF table shows the element code")
|
||||
_check(text.contains("2 Teile"), "PDF table shows the sequence part count")
|
||||
_check(
|
||||
_count(text, "Gruppe") == 1,
|
||||
"PDF table has one row per element instead of per segment"
|
||||
)
|
||||
_check(
|
||||
not text.contains("NurPfad"),
|
||||
"free-text labels of plain path segments are not table rows"
|
||||
)
|
||||
|
||||
|
||||
func _make_routine() -> Routine:
|
||||
var routine := Routine.new()
|
||||
routine.routine_id = "export-test"
|
||||
|
|
@ -318,6 +382,16 @@ func _make_routine() -> Routine:
|
|||
PathSegment.Edge.OUTSIDE
|
||||
)
|
||||
labelled.label = "3Lz & <Spin>"
|
||||
labelled.element_group_id = "el-steps"
|
||||
labelled.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 2)
|
||||
var step_two := _make_segment(
|
||||
"seg-2",
|
||||
Vector2(-10.0, -8.0),
|
||||
Vector2(0.0, 0.0),
|
||||
PathSegment.Direction.BACKWARD,
|
||||
PathSegment.Edge.INSIDE
|
||||
)
|
||||
step_two.element_group_id = "el-steps"
|
||||
var spin_marker := _make_marker(
|
||||
"seg-marker-spin",
|
||||
Vector2(-5.0, 6.0),
|
||||
|
|
@ -325,17 +399,7 @@ func _make_routine() -> Routine:
|
|||
"CCoSp4",
|
||||
3
|
||||
)
|
||||
section_one.segments = [
|
||||
labelled,
|
||||
_make_segment(
|
||||
"seg-2",
|
||||
Vector2(-10.0, -8.0),
|
||||
Vector2(0.0, 0.0),
|
||||
PathSegment.Direction.BACKWARD,
|
||||
PathSegment.Edge.INSIDE
|
||||
),
|
||||
spin_marker,
|
||||
]
|
||||
section_one.segments = [labelled, step_two, spin_marker]
|
||||
|
||||
var section_two := RoutineSection.new()
|
||||
section_two.section_id = "section-2"
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
||||
|
|
|
|||
|
|
@ -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.
|
||||
|
|
|
|||
|
|
@ -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(
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue