feat: Element-Marker mit Inspector und Export

- PathSegment traegt element_type/element_code/element_level (D3)
- Element-Werkzeug setzt Punktmarker per Tipp; Inspector fuer Typ,
  Kuerzel und Level; Marker per Griff verschiebbar
- Darstellung auf Canvas und in Praesentation inkl. Ghosting,
  Labels-Schalter blendet Kuerzel aus
- Sequenzbereiche sind getaggte Segmente, Tag ueber Inspector setzbar
- SVG/PNG-Export mit Typform und Kuerzel
- Timing-Leiste blendet irrelevante Regler im Element-Modus aus
- Griff-Drag beginnt erst mit der ersten Bewegung (kein Undo bei Tipp)
- Tests: 577 Assertions gruen; Findings, Architektur und Roadmap aktuell
This commit is contained in:
torsten 2026-10-30 23:38:57 +01:00
parent 7c6c8fc3d4
commit 5968272691
15 changed files with 1429 additions and 67 deletions

View file

@ -56,4 +56,11 @@ xvfb-run -a $GODOT --path rinkplanner \
--script res://tests/manual/capture.gd -- 1024 768 /tmp/capture.png
```
Element-Marker visuell prüfen (optional mit `place` oder `dialog`):
```bash
xvfb-run -a $GODOT --path rinkplanner \
--script res://tests/manual/capture_elements.gd -- 1400 876 /tmp/elements.png dialog
```
Exit code `0` means all assertions passed. Failures are printed to stderr.

View file

@ -0,0 +1,95 @@
extends SceneTree
## Manual visual smoke test for element markers.
##
## Usage:
## xvfb-run -a godot --path rinkplanner \
## --script res://tests/manual/capture_elements.gd -- 1400 876 /tmp/elements.png
func _init() -> void:
_capture.call_deferred()
func _capture() -> void:
var args := OS.get_cmdline_user_args()
var width := int(args[0]) if args.size() > 0 else 1400
var height := int(args[1]) if args.size() > 1 else 876
var output := args[2] if args.size() > 2 else "user://capture_elements.png"
var packed := load("res://scenes/whiteboard/whiteboard.tscn") as PackedScene
var controller := packed.instantiate() as WhiteboardController
controller.restore_autosave = false
controller.autosave_enabled = false
root.add_child(controller)
root.size = Vector2i(width, height)
await process_frame
await process_frame
controller.add_segment(
Vector2(-24.0, -10.0),
Vector2(-12.0, -10.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
controller.add_segment(
Vector2(-12.0, -10.0),
Vector2(0.0, -4.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.INSIDE,
WhiteboardController.Tool.ARC_LEFT
)
controller.add_segment(
Vector2(0.0, -4.0),
Vector2(14.0, 4.0),
PathSegment.Direction.BACKWARD,
PathSegment.Edge.OUTSIDE
)
var jump := controller.add_element_marker(
Vector2(-18.0, 2.0),
PathSegment.ElementType.JUMP,
"3Lz",
0
)
controller.add_element_marker(
Vector2(-4.0, 9.0),
PathSegment.ElementType.SPIN,
"CCoSp4",
3
)
controller.add_element_marker(
Vector2(12.0, -8.0),
PathSegment.ElementType.SEQUENCE,
"ChStSq",
2
)
# A sequence range is a normal segment that carries an element type.
var sequence := controller.add_segment(
Vector2(4.0, 12.0),
Vector2(18.0, 12.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
controller.select_segment(sequence.segment_id)
controller.set_selected_element(
PathSegment.ElementType.SEQUENCE,
"StSq",
2
)
controller.select_segment(jump.segment_id)
if args.size() > 3 and args[3] == "place":
controller.set_tool(WhiteboardController.Tool.ELEMENT)
elif args.size() > 3 and args[3] == "dialog":
controller.element_button.pressed.emit()
controller.rink_canvas.fit_rink()
controller.rink_canvas.refresh()
await process_frame
await process_frame
await RenderingServer.frame_post_draw
var path := ProjectSettings.globalize_path(output)
root.get_texture().get_image().save_png(path)
print("Saved %s at %dx%d" % [path, width, height])
quit(0)

View file

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

View file

@ -37,6 +37,26 @@ func _run() -> void:
svg.contains('paint-order="stroke"'),
"SVG labels get a white outline"
)
_check(
_count(svg, 'class="element-marker"') == 2,
"SVG contains both element markers"
)
_check(
svg.contains('data-element="3Lz"'),
"SVG names the jump marker"
)
_check(
svg.contains('data-element="CCoSp4 L3"'),
"SVG names the spin marker with its level"
)
_check(
svg.contains(">CCoSp4 L3</text>"),
"SVG draws the element caption"
)
_check(
svg.contains("<polygon points="),
"jump markers are drawn as a diamond"
)
var section_svg := RoutineSvgExporter.build(routine, "section-1")
_check(
@ -51,6 +71,14 @@ func _run() -> void:
not section_svg.contains("Abschnitt 2"),
"section export excludes the other section"
)
_check(
_count(section_svg, 'class="element-marker"') == 1,
"section export keeps its own element marker"
)
_check(
not section_svg.contains('data-element="3Lz"'),
"section export excludes markers of other sections"
)
var scene := WhiteboardScene.instantiate()
var controller := scene as WhiteboardController
@ -107,6 +135,13 @@ func _make_routine() -> Routine:
PathSegment.Edge.OUTSIDE
)
labelled.label = "3Lz & <Spin>"
var spin_marker := _make_marker(
"seg-marker-spin",
Vector2(-5.0, 6.0),
PathSegment.ElementType.SPIN,
"CCoSp4",
3
)
section_one.segments = [
labelled,
_make_segment(
@ -116,6 +151,7 @@ func _make_routine() -> Routine:
PathSegment.Direction.BACKWARD,
PathSegment.Edge.INSIDE
),
spin_marker,
]
var section_two := RoutineSection.new()
@ -133,7 +169,14 @@ func _make_routine() -> Routine:
arc.arc_bulge_left = true
arc.arc_depth_ratio = 0.4
arc.curve = _arc_curve(Vector2(0.0, 0.0), Vector2(10.0, 0.0))
section_two.segments = [arc]
var jump_marker := _make_marker(
"seg-marker-jump",
Vector2(14.0, 5.0),
PathSegment.ElementType.JUMP,
"3Lz",
0
)
section_two.segments = [arc, jump_marker]
routine.sections = [section_one, section_two]
return routine
@ -157,6 +200,22 @@ func _make_segment(
return segment
func _make_marker(
segment_id: String,
position: Vector2,
type: PathSegment.ElementType,
code: String,
level: int
) -> PathSegment:
var marker := PathSegment.new()
marker.segment_id = segment_id
marker.curve = Curve2D.new()
marker.curve.add_point(position)
marker.speed_mps = 4.3
marker.set_element(type, code, level)
return marker
func _arc_curve(from: Vector2, to: Vector2) -> Curve2D:
var curve := Curve2D.new()
var points := ArcGeometry.build_points(

View file

@ -17,6 +17,7 @@ var _failures: PackedStringArray = PackedStringArray()
func _init() -> void:
_test_rink_geometry()
_test_segment_timing()
_test_element_markers()
_test_section_aggregation()
_test_routine_validation()
_finish()
@ -167,6 +168,96 @@ func _test_segment_timing() -> void:
)
func _test_element_markers() -> void:
var jump: PathSegment = PathSegmentModel.new()
jump.segment_id = "seg-jump"
var curve := Curve2D.new()
curve.add_point(Vector2(5.0, 3.0))
jump.curve = curve
jump.duration_seconds = 0.0
jump.speed_mps = 4.3
jump.set_element(PathSegmentModel.ElementType.JUMP, " 3Lz ", 0)
_check(jump.is_marker(), "zero-length element is a marker")
_check(jump.is_element(), "element marker reports an element type")
_check(jump.is_element_marker(), "zero-length element is a point marker")
_check(jump.is_valid(), "zero-length jump marker is valid")
_check(jump.element_code == "3Lz", "element code is trimmed")
_check(
jump.get_element_caption() == "3Lz",
"jump caption is the element code"
)
_check(
PathSegmentModel.element_type_name(PathSegmentModel.ElementType.JUMP) == "Sprung",
"jump type has a German name"
)
var spin: PathSegment = PathSegmentModel.new()
spin.segment_id = "seg-spin"
spin.curve = curve
spin.duration_seconds = 0.0
spin.speed_mps = 4.3
spin.set_element(PathSegmentModel.ElementType.SPIN, "CCoSp4", 3)
_check(
spin.get_element_caption() == "CCoSp4 L3",
"spin caption includes the level"
)
_check(spin.is_valid(), "spin marker with a level is valid")
spin.set_element(PathSegmentModel.ElementType.SPIN, "", 9)
_check(spin.element_level == 4, "level is clamped to the maximum")
_check(
spin.get_element_caption() == "Pirouette L4",
"caption falls back to the type name"
)
spin.set_element(
PathSegmentModel.ElementType.SEQUENCE,
"123456789012345678901234567890",
0
)
_check(
spin.element_code.length() == PathSegmentModel.ELEMENT_CODE_MAX_LENGTH,
"element code is truncated to the maximum length"
)
_check(
spin.get_element_caption() == spin.element_code,
"sequence caption uses the truncated code"
)
spin.set_element(PathSegmentModel.ElementType.NONE, "rest", 3)
_check(
spin.element_type == PathSegmentModel.ElementType.NONE
and spin.element_code.is_empty()
and spin.element_level == 0,
"clearing the element resets code and level"
)
_check(not spin.is_element(), "cleared segment is not an element")
var missing_type: PathSegment = PathSegmentModel.new()
missing_type.segment_id = "seg-code-only"
missing_type.curve = _make_curve(Vector2(0.0, 0.0), Vector2(1.0, 0.0))
missing_type.duration_seconds = 1.0
missing_type.element_code = "3Lz"
_check(
not missing_type.is_valid(),
"element code without an element type is invalid"
)
var plain: PathSegment = _make_segment(
"seg-plain",
1.0,
Vector2(0.0, 0.0),
Vector2(1.0, 0.0)
)
_check(not plain.is_element(), "plain segment has no element")
_check(not plain.is_element_marker(), "plain segment is not a point marker")
_check(
plain.get_element_caption() == "Element",
"plain segment caption falls back to the generic name"
)
func _test_section_aggregation() -> void:
var section: RoutineSection = RoutineSectionModel.new()
section.section_id = "section-steps"

View file

@ -83,6 +83,49 @@ func _run() -> void:
"synthetic mouse after touch is ignored"
)
# Element tool: a single tap drops a marker, a drag still pans.
controller.set_tool(WhiteboardController.Tool.ELEMENT)
var count_before_marker := section.segments.size()
var marker_screen := view.model_to_screen(Vector2(6.0, 6.0))
_touch(canvas, 0, marker_screen, true)
_touch(canvas, 0, marker_screen, false)
_check(
section.segments.size() == count_before_marker + 1,
"one tap places an element marker"
)
var placed_marker := section.segments[section.segments.size() - 1]
_check(
placed_marker.is_element_marker(),
"tapped marker is a zero-length element"
)
_check(
controller.get_selected_segment() == placed_marker,
"placed marker is selected for the inspector"
)
controller.set_tool(WhiteboardController.Tool.SELECT)
controller.clear_selection()
_check(
controller.get_selected_segment() == null,
"selection can be cleared before tapping"
)
var undo_before := controller.undo_button.disabled
_touch(canvas, 0, marker_screen, true)
_touch(canvas, 0, marker_screen, false)
_check(
controller.get_selected_segment() == placed_marker,
"tapping the marker selects it"
)
_check_vec(
placed_marker.curve.get_point_position(0),
Vector2(6.0, 6.0),
"tapping the marker does not move it"
)
_check(
controller.undo_button.disabled == undo_before,
"tapping a marker leaves the undo button state alone"
)
# Two-finger pan.
controller.set_tool(WhiteboardController.Tool.SELECT)
var count_before_pan := section.segments.size()

View file

@ -619,6 +619,214 @@ func _run() -> void:
controller.set_selected_segment_label("Eingang")
var saved_label := controller.get_selected_segment_label()
# Element markers (D3): a jump point/spin centre is a zero-length segment.
controller.set_tool(WhiteboardController.Tool.ELEMENT)
_check(
canvas.is_marker_placement_enabled(),
"element tool enables marker placement"
)
var marker_count_before := section.segments.size()
var jump_point := Vector2(14.0, 7.0)
_mouse_button(canvas, view.model_to_screen(jump_point), true)
_mouse_button(canvas, view.model_to_screen(jump_point), false)
var jump := controller.get_selected_segment()
_check(
section.segments.size() == marker_count_before + 1,
"tap in element mode adds a marker"
)
_check(jump != null and jump.is_element_marker(), "placed marker is a point marker")
if jump != null:
_check_approx(jump.get_length_m(), 0.0, "marker has no length")
_check_approx(jump.duration_seconds, 0.0, "marker has no duration")
_check(
jump.element_type == PathSegment.ElementType.JUMP,
"default marker type is a jump"
)
_check(
jump.get_element_caption() == "Sprung",
"marker falls back to the type name"
)
_check(
controller.status_label.text.contains("Sprung"),
"status bar names the placed element"
)
_check_approx(
controller.get_playback_duration(),
routine.get_duration_seconds(),
"markers do not add playback time"
)
# 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
controller.set_tool(WhiteboardController.Tool.SELECT)
controller.select_segment(jump_id)
var marker_tap := view.model_to_screen(jump_point)
_mouse_button(canvas, marker_tap, true)
_mouse_button(canvas, marker_tap, false)
_check(controller.undo(), "tap on a marker handle is undoable")
section = controller.get_active_section()
_check(
section.get_segment_by_id(jump_id) == null,
"a plain tap adds no undo entry, so undo removes the marker"
)
_check(controller.redo(), "marker placement can be redone")
section = controller.get_active_section()
jump = section.get_segment_by_id(jump_id)
_check(jump != null, "redo restores the placed marker")
controller.set_tool(WhiteboardController.Tool.ELEMENT)
controller.set_element_type(PathSegment.ElementType.SPIN)
_check(
controller.get_element_type() == PathSegment.ElementType.SPIN,
"element type can be selected for placement"
)
var spin_point := Vector2(6.0, -6.0)
_mouse_button(canvas, view.model_to_screen(spin_point), true)
_mouse_button(canvas, view.model_to_screen(spin_point), false)
var spin := controller.get_selected_segment()
_check(
spin != null and spin.element_type == PathSegment.ElementType.SPIN,
"toolbar type is used for the next marker"
)
_check(
controller.set_selected_element(
PathSegment.ElementType.SPIN,
"CCoSp4",
3
),
"element code and level can be edited"
)
_check(
spin.get_element_caption() == "CCoSp4 L3",
"marker caption includes code and level"
)
_check(controller.undo(), "element edit can be undone")
var restored_spin := controller.get_active_section().get_segment_by_id(
spin.segment_id
)
_check(
restored_spin != null
and restored_spin.element_code.is_empty()
and restored_spin.element_level == 0,
"undo restores the previous element data"
)
_check(controller.redo(), "element edit can be redone")
spin = controller.get_active_section().get_segment_by_id(spin.segment_id)
_check(
spin != null and spin.get_element_caption() == "CCoSp4 L3",
"redo restores the element data"
)
# Element inspector dialog.
controller.select_segment(spin.segment_id)
controller.element_button.pressed.emit()
_check(controller.element_dialog.visible, "element button opens the dialog")
_check(
controller.element_code_edit.text == "CCoSp4",
"element dialog is prefilled with the code"
)
controller.element_code_edit.text = "CCoSp3"
controller.element_level_option.select(
controller.element_level_option.get_item_index(2)
)
controller.element_dialog.confirmed.emit()
_check(
controller.get_selected_element_caption() == "CCoSp3 L2",
"element dialog applies code and level"
)
controller.element_dialog.hide()
# Dragging the marker handle moves the point.
controller.set_tool(WhiteboardController.Tool.SELECT)
controller.select_segment(spin.segment_id)
var moved_to := Vector2(4.0, -3.0)
var marker_screen := view.model_to_screen(spin_point)
var marker_target := view.model_to_screen(moved_to)
_mouse_button(canvas, marker_screen, true)
_mouse_motion(canvas, marker_target, marker_target - marker_screen)
_mouse_button(canvas, marker_target, false)
_check_vec(
spin.curve.get_point_position(0),
moved_to,
"dragging the marker handle moves the element"
)
_check(controller.undo(), "marker drag can be undone")
var unmoved := controller.get_active_section().get_segment_by_id(spin.segment_id)
_check(
unmoved != null and unmoved.curve.point_count == 1,
"undo keeps the marker a single point"
)
_check_vec(
unmoved.curve.get_point_position(0),
spin_point,
"undo restores the marker position"
)
_check(controller.redo(), "marker drag can be redone")
# Deleting through the inspector: a marker without an element is removed.
controller.select_segment(spin.segment_id)
controller.set_selected_element(PathSegment.ElementType.NONE, "", 0)
_check(
controller.get_active_section().get_segment_by_id(spin.segment_id) == null,
"removing the element deletes the point marker"
)
_check(
controller.get_selected_segment() == null,
"deleting the marker clears the selection"
)
_check(controller.undo(), "marker deletion can be undone")
spin = controller.get_active_section().get_segment_by_id(spin.segment_id)
_check(
spin != null and spin.is_element_marker(),
"undo restores the deleted marker"
)
# A drawn segment can be tagged as a sequence range and untagged again.
var range_segment := controller.add_segment(
Vector2(-2.0, 11.0),
Vector2(10.0, 11.0),
PathSegment.Direction.FORWARD,
PathSegment.Edge.OUTSIDE
)
controller.select_segment(range_segment.segment_id)
_check(
controller.set_selected_element(
PathSegment.ElementType.SEQUENCE,
"StSq",
2
),
"a drawn segment can carry a sequence element"
)
_check(
controller.get_selected_element_caption() == "StSq L2",
"sequence range caption combines code and level"
)
_check(
controller.set_selected_element(PathSegment.ElementType.NONE, "", 0),
"the element tag can be removed from a range"
)
var untagged := controller.get_active_section().get_segment_by_id(
range_segment.segment_id
)
_check(
untagged != null and untagged.get_length_m() > 0.0,
"removing the tag keeps the drawn path"
)
_check(
not untagged.is_element(),
"removed range is no longer an element"
)
_check(
controller.get_element_type() != PathSegment.ElementType.NONE,
"removing a tag keeps a usable placement type"
)
controller.set_tool(WhiteboardController.Tool.LINE)
var saved_marker_id: String = jump.segment_id
# Save/load round-trip.
var roundtrip_path := "user://test_roundtrip.tres"
var saved_section_title := controller.get_active_section().title
@ -679,6 +887,25 @@ func _run() -> void:
"load restores the segment label"
)
var loaded_marker := controller.get_active_section().get_segment_by_id(
saved_marker_id
)
_check(loaded_marker != null, "load restores element markers")
if loaded_marker != null:
_check(loaded_marker.is_element_marker(), "loaded marker stays a point marker")
_check(
loaded_marker.element_type == PathSegment.ElementType.JUMP,
"load restores the element type"
)
_check(
loaded_marker.get_element_caption() == "Sprung",
"load restores the element caption"
)
_check(
loaded_marker.curve.point_count == 1,
"load keeps the marker curve as a single point"
)
DirAccess.remove_absolute(roundtrip_path)
var too_new_path := "user://test_too_new.tres"