feat: create ellipses from geometry (#84)

* feat: create ellipses from geometry

* test: geometry test for ellipse

* feat: removed required angle and added tests

* test: completed tests for geometry

* chore: unused import

* Update lib/game/components/pathway.dart

Co-authored-by: Allison Ryan <77211884+allisonryan0002@users.noreply.github.com>

* refactor: renaming params

* chore: missed test saved

Co-authored-by: Allison Ryan <77211884+allisonryan0002@users.noreply.github.com>

lib/game/components/pathway.dart

@@ -144,6 +144,46 @@ class Pathway extends BodyComponent with InitialPosition, Layered {
     );
   }
 
+  /// Creates an ellipse [Pathway].
+  ///
+  /// Does so with two [ChainShape]s separated by a [width]. Can
+  /// be rotated by a given [rotation] in radians.
+  ///
+  /// If [singleWall] is true, just one [ChainShape] is created.
+  factory Pathway.ellipse({
+    Color? color,
+    required Vector2 center,
+    required double width,
+    required double majorRadius,
+    required double minorRadius,
+    double rotation = 0,
+    bool singleWall = false,
+  }) {
+    final paths = <List<Vector2>>[];
+
+    // TODO(ruialonso): Refactor repetitive logic
+    final outerWall = calculateEllipse(
+      center: center,
+      majorRadius: majorRadius,
+      minorRadius: minorRadius,
+    ).map((vector) => vector..rotate(rotation)).toList();
+    paths.add(outerWall);
+
+    if (!singleWall) {
+      final innerWall = calculateEllipse(
+        center: center,
+        majorRadius: majorRadius - width,
+        minorRadius: minorRadius - width,
+      ).map((vector) => vector..rotate(rotation)).toList();
+      paths.add(innerWall);
+    }
+
+    return Pathway._(
+      color: color,
+      paths: paths,
+    );
+  }
+
   final List<List<Vector2>> _paths;
 
   /// Constructs different [ChainShape]s to form the [Pathway] shape.

lib/game/pinball_game.dart

@@ -1,5 +1,4 @@
 // ignore_for_file: public_member_api_docs
-
 import 'dart:async';
 import 'package:flame/extensions.dart';
 import 'package:flame/input.dart';

packages/geometry/lib/src/geometry.dart

@@ -23,10 +23,45 @@ List<Vector2> calculateArc({
 
   final points = <Vector2>[];
   for (var i = 0; i < precision; i++) {
-    final xCoord = center.x + radius * math.cos((stepAngle * i) + offsetAngle);
-    final yCoord = center.y - radius * math.sin((stepAngle * i) + offsetAngle);
+    final x = center.x + radius * math.cos((stepAngle * i) + offsetAngle);
+    final y = center.y - radius * math.sin((stepAngle * i) + offsetAngle);
 
-    final point = Vector2(xCoord, yCoord);
+    final point = Vector2(x, y);
+    points.add(point);
+  }
+
+  return points;
+}
+
+/// Calculates all [Vector2]s of an ellipse.
+///
+/// An ellipse can be achieved by specifying a [center], a [majorRadius] and a
+/// [minorRadius].
+///
+/// The higher the [precision], the more [Vector2]s will be calculated;
+/// achieving a more rounded ellipse.
+///
+/// For more information read: https://en.wikipedia.org/wiki/Ellipse.
+List<Vector2> calculateEllipse({
+  required Vector2 center,
+  required double majorRadius,
+  required double minorRadius,
+  int precision = 100,
+}) {
+  assert(
+    0 < minorRadius && minorRadius <= majorRadius,
+    'smallRadius ($minorRadius) and bigRadius ($majorRadius) must be in '
+    'range 0 < smallRadius <= bigRadius',
+  );
+
+  final stepAngle = 2 * math.pi / (precision - 1);
+
+  final points = <Vector2>[];
+  for (var i = 0; i < precision; i++) {
+    final x = center.x + minorRadius * math.cos(stepAngle * i);
+    final y = center.y - majorRadius * math.sin(stepAngle * i);
+
+    final point = Vector2(x, y);
     points.add(point);
   }
 
@@ -63,17 +98,15 @@ List<Vector2> calculateBezierCurve({
   final points = <Vector2>[];
 
   do {
-    var xCoord = 0.0;
-    var yCoord = 0.0;
+    var x = 0.0;
+    var y = 0.0;
     for (var i = 0; i <= n; i++) {
       final point = controlPoints[i];
 
-      xCoord +=
-          binomial(n, i) * math.pow(1 - t, n - i) * math.pow(t, i) * point.x;
-      yCoord +=
-          binomial(n, i) * math.pow(1 - t, n - i) * math.pow(t, i) * point.y;
+      x += binomial(n, i) * math.pow(1 - t, n - i) * math.pow(t, i) * point.x;
+      y += binomial(n, i) * math.pow(1 - t, n - i) * math.pow(t, i) * point.y;
     }
-    points.add(Vector2(xCoord, yCoord));
+    points.add(Vector2(x, y));
 
     t = t + step;
   } while (t <= 1);

packages/geometry/test/src/geometry_test.dart

@@ -33,6 +33,46 @@ void main() {
     });
   });
 
+  group('calculateEllipse', () {
+    test('returns by default 100 points as indicated by precision', () {
+      final points = calculateEllipse(
+        center: Vector2.zero(),
+        majorRadius: 100,
+        minorRadius: 50,
+      );
+      expect(points.length, 100);
+    });
+
+    test('returns as many points as indicated by precision', () {
+      final points = calculateEllipse(
+        center: Vector2.zero(),
+        majorRadius: 100,
+        minorRadius: 50,
+        precision: 50,
+      );
+      expect(points.length, 50);
+    });
+
+    test('fails if radius not in range', () {
+      expect(
+        () => calculateEllipse(
+          center: Vector2.zero(),
+          majorRadius: 100,
+          minorRadius: 150,
+        ),
+        throwsA(isA<AssertionError>()),
+      );
+      expect(
+        () => calculateEllipse(
+          center: Vector2.zero(),
+          majorRadius: 100,
+          minorRadius: 0,
+        ),
+        throwsA(isA<AssertionError>()),
+      );
+    });
+  });
+
   group('calculateBezierCurve', () {
     test('fails if step not in range', () {
       expect(

test/game/components/pathway_test.dart

@@ -165,6 +165,42 @@ void main() {
       });
     });
 
+    group('ellipse', () {
+      flameTester.test(
+        'loads correctly',
+        (game) async {
+          final pathway = Pathway.ellipse(
+            center: Vector2.zero(),
+            width: width,
+            majorRadius: 150,
+            minorRadius: 70,
+          );
+          await game.ready();
+          await game.ensureAdd(pathway);
+
+          expect(game.contains(pathway), isTrue);
+        },
+      );
+
+      group('body', () {
+        flameTester.test(
+          'is static',
+          (game) async {
+            final pathway = Pathway.ellipse(
+              center: Vector2.zero(),
+              width: width,
+              majorRadius: 150,
+              minorRadius: 70,
+            );
+            await game.ready();
+            await game.ensureAdd(pathway);
+
+            expect(pathway.body.bodyType, equals(BodyType.static));
+          },
+        );
+      });
+    });
+
     group('bezier curve', () {
       final controlPoints = [
         Vector2(0, 0),