rinkplanner/rinkplanner/tests/run_canvas_tests.gd
torsten a1d399f575 feat: Geschwister einer Step Sequence türkis hervorheben
Wird ein Segment aus einer Elementgruppe ausgewählt, umrandet der Canvas die
übrigen Mitglieder türkis; das gewählte Segment behält den gelben Halo. Damit
ist auf einen Blick sichtbar, welche Teilstrecken zur Sequenz gehören.

- RinkCanvas.get_group_member_segment_ids() liefert die Geschwister
  (gleiche element_group_id, ohne Auswahl, ohne bereits mit ausgewählte)
- Zeichnung unter dem gelben Halo, gestrichelt bei Rückwärtssegmenten
- Tests in run_canvas_tests.gd, Sichtprüfung über
  tests/manual/capture_group_highlight.gd
- Findings zu den Step-Sequence-Gruppen aktualisiert
2026-11-12 06:16:57 +01:00

265 lines
8.3 KiB
GDScript

extends SceneTree
## Headless tests for the 2D canvas view helpers (no rendering required).
##
## Run with:
## godot --headless --path rinkplanner --script res://tests/run_canvas_tests.gd
const CanvasTransformModel := preload("res://src/whiteboard/view/canvas_transform.gd")
const RinkDimensionsModel := preload("res://src/core/model/rink_dimensions.gd")
const ArcGeometryModel := preload("res://src/core/model/arc_geometry.gd")
var _assertions: int = 0
var _failures: PackedStringArray = PackedStringArray()
func _init() -> void:
_test_transform_round_trip()
_test_fit_rect()
_test_zoom_keeps_point()
_test_zoom_limits()
_test_pan()
_test_visible_rect()
_test_rink_outline()
_test_arc_geometry()
_test_group_member_highlight()
_finish()
func _test_transform_round_trip() -> void:
var transform: CanvasTransform = CanvasTransformModel.new()
transform.pixels_per_meter = 20.0
transform.origin_px = Vector2(100.0, 50.0)
var model_point := Vector2(3.0, -2.0)
var screen_point := transform.model_to_screen(model_point)
_check_vec(screen_point, Vector2(160.0, 10.0), "model point maps to screen")
_check_vec(transform.screen_to_model(screen_point), model_point, "screen mapping round-trips")
func _test_fit_rect() -> void:
var transform: CanvasTransform = CanvasTransformModel.new()
transform.fit_rect(Rect2(Vector2(-30.0, -15.0), Vector2(60.0, 30.0)), Vector2(1000.0, 600.0), 20.0)
_check_approx(transform.pixels_per_meter, 16.0, "fit uses the limiting axis")
_check_vec(transform.model_to_screen(Vector2.ZERO), Vector2(500.0, 300.0), "fit centers the rink")
func _test_zoom_keeps_point() -> void:
var transform: CanvasTransform = CanvasTransformModel.new()
transform.pixels_per_meter = 20.0
transform.origin_px = Vector2(500.0, 300.0)
var zoom_point := Vector2(250.0, 150.0)
var model_before := transform.screen_to_model(zoom_point)
transform.zoom_at(zoom_point, 2.0)
var model_after := transform.screen_to_model(zoom_point)
_check_approx(transform.pixels_per_meter, 40.0, "zoom scales pixels per meter")
_check_vec(model_after, model_before, "zoom keeps the model point under the cursor")
func _test_zoom_limits() -> void:
var transform: CanvasTransform = CanvasTransformModel.new()
transform.zoom_at(Vector2.ZERO, 100000.0)
_check_approx(
transform.pixels_per_meter,
CanvasTransformModel.MAX_PIXELS_PER_METER,
"zoom is clamped at the maximum"
)
transform.zoom_at(Vector2.ZERO, 0.000001)
_check_approx(
transform.pixels_per_meter,
CanvasTransformModel.MIN_PIXELS_PER_METER,
"zoom is clamped at the minimum"
)
func _test_pan() -> void:
var transform: CanvasTransform = CanvasTransformModel.new()
var origin_before := transform.origin_px
transform.pan(Vector2(25.0, -10.0))
_check_vec(transform.origin_px, origin_before + Vector2(25.0, -10.0), "pan shifts the origin")
func _test_visible_rect() -> void:
var transform: CanvasTransform = CanvasTransformModel.new()
transform.pixels_per_meter = 10.0
transform.origin_px = Vector2(400.0, 300.0)
var visible := transform.get_visible_model_rect(Vector2(800.0, 600.0))
_check_vec(visible.position, Vector2(-40.0, -30.0), "visible rect starts at the top-left model point")
_check_vec(visible.size, Vector2(80.0, 60.0), "visible rect size follows viewport and scale")
func _test_rink_outline() -> void:
var rink: RinkDimensions = RinkDimensionsModel.new()
var segments := 12
var points := rink.get_outline_points(segments)
_check(points.size() == 4 * (segments + 1), "outline has one point per arc segment")
_check_vec(points[0], Vector2(30.0, 6.5), "outline starts at the right board")
for point: Vector2 in points:
_check(
rink.contains_point(point),
"outline point stays on the rink surface: %s" % point
)
var corner_center := Vector2(30.0 - 8.5, 15.0 - 8.5)
var corner_point := corner_center + Vector2(cos(PI * 0.25), sin(PI * 0.25)) * 8.5
_check_approx(
corner_point.distance_to(corner_center),
8.5,
"corner arc keeps the configured radius"
)
_check(rink.contains_point(corner_point), "corner arc lies on the rink surface")
func _test_arc_geometry() -> void:
var rink: RinkDimensions = RinkDimensionsModel.new()
var start := Vector2(-10.0, 0.0)
var end := Vector2(10.0, 0.0)
var left := ArcGeometryModel.build_points(start, end, true, 0.4, rink)
_check(left.size() > 2, "arc geometry returns a sampled curve")
_check_vec(left[0], start, "arc keeps the start point")
_check_vec(left[left.size() - 1], end, "arc keeps the end point")
_check(left[left.size() / 2].y > 1.0, "left arc bulges left of the chord")
var right := ArcGeometryModel.build_points(start, end, false, 0.4, rink)
_check(right[right.size() / 2].y < -1.0, "right arc bulges right of the chord")
var shallow := ArcGeometryModel.build_points(start, end, true, 0.15, rink)
var deep := ArcGeometryModel.build_points(start, end, true, 0.45, rink)
_check(
absf(deep[deep.size() / 2].y) > absf(shallow[shallow.size() / 2].y),
"larger depth ratio produces a deeper arc"
)
var near_board := ArcGeometryModel.build_points(
Vector2(-10.0, 10.0),
Vector2(10.0, 10.0),
true,
0.4,
rink
)
for point: Vector2 in near_board:
_check(
rink.contains_point(point),
"arc near the board is flattened: %s" % point
)
_check_approx(
ArcGeometryModel.depth_ratio_for_point(start, end, Vector2(0.0, 8.0)),
0.4,
"depth ratio is derived from the point distance"
)
_check(
ArcGeometryModel.is_left_of_chord(start, end, Vector2(0.0, 8.0)),
"point above the chord reports as left"
)
_check(
not ArcGeometryModel.is_left_of_chord(start, end, Vector2(0.0, -8.0)),
"point below the chord reports as right"
)
func _test_group_member_highlight() -> void:
var canvas := RinkCanvas.new()
var routine: Routine = Routine.new()
var section: RoutineSection = RoutineSection.new()
section.section_id = "sec-steps"
var first := _make_step_segment("seg-steps-1", "el-steps")
var second := _make_step_segment("seg-steps-2", "el-steps")
var third := _make_step_segment("seg-steps-3", "el-steps")
first.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 2)
var solo := _make_step_segment("seg-solo", "")
solo.set_element(PathSegment.ElementType.SEQUENCE, "StSq", 2)
section.segments = [first, second, third, solo]
routine.sections = [section]
canvas.set_routine(routine, false)
canvas.set_active_section("sec-steps")
canvas.set_selected_segment("seg-steps-2")
var siblings := canvas.get_group_member_segment_ids()
_check(siblings.size() == 2, "a group member reports its two siblings")
_check(
siblings.has("seg-steps-1") and siblings.has("seg-steps-3"),
"the siblings are the other group members"
)
_check(
not siblings.has("seg-steps-2"),
"the selected segment is not its own sibling"
)
_check(
not siblings.has("seg-solo"),
"segments outside the group are ignored"
)
canvas.set_selected_segment("seg-solo")
_check(
canvas.get_group_member_segment_ids().is_empty(),
"a standalone element has no siblings"
)
canvas.set_selected_segments(
PackedStringArray(["seg-steps-1", "seg-steps-2"]),
"seg-steps-2"
)
var multi := canvas.get_group_member_segment_ids()
_check(
multi.size() == 1 and multi.has("seg-steps-3"),
"already selected siblings are not highlighted twice"
)
canvas.set_selected_segment("")
_check(
canvas.get_group_member_segment_ids().is_empty(),
"no selection means no sibling highlight"
)
canvas.free()
func _make_step_segment(segment_id: String, group_id: String) -> PathSegment:
var segment: PathSegment = PathSegment.new()
segment.segment_id = segment_id
segment.element_group_id = group_id
var curve := Curve2D.new()
curve.add_point(Vector2.ZERO)
curve.add_point(Vector2(1.0, 0.0))
segment.curve = curve
return segment
func _check(condition: bool, message: String) -> void:
_assertions += 1
if not condition:
_failures.append(message)
func _check_approx(actual: float, expected: float, message: String) -> void:
_check(
absf(actual - expected) <= 0.001,
"%s (expected %.3f, got %.3f)" % [message, expected, actual]
)
func _check_vec(actual: Vector2, expected: Vector2, message: String) -> void:
_check(
actual.distance_to(expected) <= 0.001,
"%s (expected %s, got %s)" % [message, expected, actual]
)
func _finish() -> void:
if _failures.is_empty():
print("PASS: %d assertions" % _assertions)
quit(0)
return
for failure: String in _failures:
printerr("FAIL: %s" % failure)
printerr("%d of %d assertions failed" % [_failures.size(), _assertions])
quit(1)