fix!: Remove middle intersection point on shared line segments in collision detection (#4004)

When two line segments were collinear and overlapping,
`LineSegment.intersections` returned a single synthetic point: the
average of the overlap's end points. For shape collision detection this
meant that two shapes sharing an edge (for example two axis-aligned
rectangles standing side by side) reported both the real corner points
and an extra point in the middle of the shared edge.

This PR changes the collinear-overlap case of
`LineSegment.intersections` to return the actual end points of the
overlapping section instead of their average. Segments that only touch
in a single point still return that one point. As a result, collision
detection on shared edges now only reports the end points of the shared
segment, without the synthetic middle point.

The dartdoc on `LineSegment.intersections` and
`PolygonPolygonIntersections.intersect` has been updated to describe the
new behavior, and the affected tests now assert the overlap end points.

Author: spydon

packages/flame/lib/src/geometry/line.dart

@@ -27,7 +27,7 @@ class Line {
     final determinant = a * otherLine.b - otherLine.a * b;
     if (determinant == 0) {
       //The lines are parallel (potentially coincides) and have no intersection
-      return [];
+      return const [];
     }
     return [
       Vector2(

packages/flame/lib/src/geometry/line_segment.dart

@@ -64,9 +64,11 @@ class LineSegment {
     return inflate(-amount);
   }
 
-  /// Returns an empty list if there are no intersections between the segments
-  /// If the segments are concurrent, the intersecting point is returned as a
-  /// list with a single point
+  /// Returns an empty list if there are no intersections between the segments.
+  /// If the segments intersect in a single point, that point is returned in a
+  /// list with a single element.
+  /// If the segments are collinear and overlap, the end points of the
+  /// overlapping section are returned.
   List<Vector2> intersections(LineSegment otherSegment) {
     final result = toLine().intersections(otherSegment.toLine());
     if (result.isNotEmpty) {
@@ -86,14 +88,10 @@ class LineSegment {
         if (containsPoint(otherSegment.to)) otherSegment.to,
       };
       if (overlaps.isNotEmpty) {
-        final sum = Vector2.zero();
-        for (final overlap in overlaps) {
-          sum.add(overlap);
-        }
-        return [sum..scale(1 / overlaps.length)];
+        return overlaps.toList(growable: false);
       }
     }
-    return [];
+    return const [];
   }
 
   /// Whether the given [point] lies in this line segment.

packages/flame/lib/src/geometry/shape_intersections.dart

@@ -31,8 +31,8 @@ class PolygonPolygonIntersections
     extends Intersections<PolygonComponent, PolygonComponent> {
   /// Returns the intersection points of [polygonA] and [polygonB]
   /// The two polygons are required to be convex
-  /// If they share a segment of a line, both end points and the center point of
-  /// that line segment will be counted as collision points
+  /// If they share a segment of a line, both end points of that segment will
+  /// be counted as collision points
   @override
   List<Vector2> intersect(
     PolygonComponent polygonA,

packages/flame/test/collisions/collision_detection_test.dart

@@ -107,23 +107,21 @@ void main() {
       final segmentB = LineSegment(Vector2.all(0), Vector2.all(1));
       final intersection = segmentA.intersections(segmentB);
       expect(
-        intersection.isNotEmpty,
-        true,
-        reason: 'Should have intersection at (0.5, 0.5)',
+        intersection,
+        unorderedEquals([Vector2.all(0), Vector2.all(1)]),
+        reason: 'Should intersect at the end points of the overlap',
       );
-      expect(intersection.first == Vector2.all(0.5), true);
     });
 
     test('overlapping line segments', () {
       final segmentA = LineSegment(Vector2.all(0), Vector2.all(1));
       final segmentB = LineSegment(Vector2.all(0.5), Vector2.all(1.5));
       final intersection = segmentA.intersections(segmentB);
       expect(
-        intersection.isNotEmpty,
-        true,
-        reason: 'Should intersect at (0.75, 0.75)',
+        intersection,
+        unorderedEquals([Vector2.all(0.5), Vector2.all(1)]),
+        reason: 'Should intersect at the end points of the overlap',
       );
-      expect(intersection.first == Vector2.all(0.75), true);
     });
 
     test('one pixel overlap in different angles', () {
@@ -312,13 +310,12 @@ void main() {
         intersections,
         containsAll([
           Vector2(2.0, 2.0),
-          Vector2(2.0, 1.5),
           Vector2(2.0, 1.0),
         ]),
         reason: 'Does not have all the correct intersection points',
       );
       expect(
-        intersections.length == 3,
+        intersections.length == 2,
         true,
         reason: 'Wrong number of intersections',
       );
@@ -377,15 +374,13 @@ void main() {
         containsAll([
           Vector2(2, 0),
           Vector2(2, 2),
-          Vector2(1, 0),
           Vector2(0, 0),
-          Vector2(0, 1),
           Vector2(0, 2),
         ]),
         reason: 'Does not have all the correct intersection points',
       );
       expect(
-        intersections.length == 6,
+        intersections.length == 4,
         true,
         reason: 'Wrong number of intersections',
       );
@@ -457,13 +452,12 @@ void main() {
         intersections,
         containsAll([
           Vector2(4, 0),
-          Vector2(4, 2),
           Vector2(4, 4),
         ]),
         reason: 'Missed intersections',
       );
       expect(
-        intersections.length == 3,
+        intersections.length == 2,
         true,
         reason: 'Wrong number of intersections',
       );