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

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

View file

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

After

Width:  |  Height:  |  Size: 234 B

View file

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

View file

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

After

Width:  |  Height:  |  Size: 208 B

View file

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

View file

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

After

Width:  |  Height:  |  Size: 278 B

View file

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

View file

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

After

Width:  |  Height:  |  Size: 472 B

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

File diff suppressed because it is too large Load diff

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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

View file

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