Duration can not be zero

doc/examples/effects/simple/lib/main_move.dart

@@ -29,7 +29,7 @@ class MyGame extends BaseGame with TapDetector {
       speed: 250.0,
       curve: Curves.bounceInOut,
       isRelative: false,
-      isInfinite: true,
+      isInfinite: false,
       isAlternating: true,
     ));
   }

lib/effects/effects.dart

@@ -1,5 +1,3 @@
-import 'dart:math';
-
 import 'package:flutter/foundation.dart';
 import 'package:flutter/material.dart';
 
@@ -60,7 +58,7 @@ abstract class ComponentEffect<T extends Component> {
     }
     if (!hasFinished()) {
       currentTime += (dt + driftTime) * curveDirection;
-      currentTime = (currentTime * 10000000).round() / 10000000;
+      currentTime = (currentTime * 10000000).floor() / 10000000;
       percentage = (currentTime / peakTime).clamp(0.0, 1.0).toDouble();
       curveProgress = curve.transform(percentage);
       _updateDriftTime();

test/effects/effect_test_utils.dart

@@ -41,8 +41,6 @@ void effectTest(
     game.update(stepDelta);
     timeLeft -= stepDelta;
   }
-  expect(effect.hasFinished(), shouldFinish, reason: "Effect shouldFinish");
-  expect(callback.isCalled, shouldFinish, reason: "Callback was treated wrong");
   if (!shouldFinish) {
     const double floatRange = 0.001;
     bool acceptableVector(Vector2 vector, Vector2 expectedVector) {
@@ -56,18 +54,18 @@ void effectTest(
         (expectedAngle - component.angle).abs() < floatRange;
     assert(
       acceptablePosition,
-      "Position is not correct (${component.position} vs $expectedPosition)",
+      "Position is not correct (had: ${component.position} should be $expectedPosition)",
     );
     assert(
       acceptableAngle,
-      "Angle is not correct (${component.angle} vs $expectedAngle)",
+      "Angle is not correct (had: ${component.angle} should be: $expectedAngle)",
     );
     assert(
       acceptableSize,
-      "Size is not correct (${component.size} vs $expectedSize)",
+      "Size is not correct (had: ${component.size} should be: $expectedSize)",
     );
   } else {
-    //game.update(0.1);
+    game.update(0.1);
     expect(
       component.position,
       expectedPosition,
@@ -84,12 +82,14 @@ void effectTest(
       reason: "Size is not exactly correct",
     );
   }
+  expect(effect.hasFinished(), shouldFinish, reason: "Effect shouldFinish");
+  expect(callback.isCalled, shouldFinish, reason: "Callback was treated wrong");
   game.update(0.0); // Since effects are removed before they are updated
   expect(component.effects.isEmpty, shouldFinish);
 }
 
-class Square extends PositionComponent {
-  Square({
+class TestComponent extends PositionComponent {
+  TestComponent({
     Vector2 position,
     Vector2 size,
     double angle,

test/effects/move_effect_test.dart

@@ -11,23 +11,22 @@ void main() {
   final Random random = Random();
   Vector2 randomVector2() => (Vector2.random(random) * 100)..round();
   final List<Vector2> path = List.generate(3, (i) => randomVector2());
-  Square component() => Square(position: randomVector2());
+  TestComponent component() => TestComponent(position: randomVector2());
 
   MoveEffect effect(bool isInfinite, bool isAlternating) {
     return MoveEffect(
       path: path,
-      duration: random.nextInt(100).toDouble(),
+      duration: 1 + random.nextInt(100).toDouble(),
       isInfinite: isInfinite,
       isAlternating: isAlternating,
     );
   }
 
   testWidgets('MoveEffect can move', (WidgetTester tester) async {
-    final MoveEffect moveEffect = effect(false, false);
     effectTest(
       tester,
       component(),
-      moveEffect,
+      effect(false, false),
       expectedPosition: path.last,
     );
   });
@@ -35,11 +34,10 @@ void main() {
   testWidgets(
     'MoveEffect will stop moving after it is done',
     (WidgetTester tester) async {
-      final MoveEffect moveEffect = effect(false, false);
       effectTest(
         tester,
         component(),
-        moveEffect,
+        effect(false, false),
         expectedPosition: path.last,
         iterations: 1.5,
       );
@@ -47,12 +45,11 @@ void main() {
   );
 
   testWidgets('MoveEffect can alternate', (WidgetTester tester) async {
-    final MoveEffect moveEffect = effect(false, true);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      moveEffect,
+      effect(false, true),
       expectedPosition: positionComponent.position.clone(),
     );
   });
@@ -60,12 +57,11 @@ void main() {
   testWidgets(
     'MoveEffect can alternate and be infinite',
     (WidgetTester tester) async {
-      final MoveEffect moveEffect = effect(true, true);
       final PositionComponent positionComponent = component();
       effectTest(
         tester,
         positionComponent,
-        moveEffect,
+        effect(true, true),
         expectedPosition: positionComponent.position.clone(),
         iterations: 1.0,
         shouldFinish: false,
@@ -74,12 +70,11 @@ void main() {
   );
 
   testWidgets('MoveEffect alternation can peak', (WidgetTester tester) async {
-    final MoveEffect moveEffect = effect(false, true);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      moveEffect,
+      effect(false, true),
       expectedPosition: path.last,
       shouldFinish: false,
       iterations: 0.5,
@@ -87,12 +82,11 @@ void main() {
   });
 
   testWidgets('MoveEffect can be infinite', (WidgetTester tester) async {
-    final MoveEffect moveEffect = effect(true, false);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      moveEffect,
+      effect(true, false),
       expectedPosition: path.last,
       iterations: 3.0,
       shouldFinish: false,

test/effects/rotate_effect_test.dart

@@ -7,32 +7,23 @@ import 'package:flutter_test/flutter_test.dart';
 import 'effect_test_utils.dart';
 
 void main() {
-  final Random random = Random();
-  double roundDouble(double value, int places) {
-    final double mod = pow(10.0, places).toDouble();
-    return (value * mod).round().toDouble() / mod;
-  }
-
-  // Max three rotations
-  double randomAngle() => roundDouble(random.nextDouble() * 6 * pi, 2);
-  final double angleArgument = randomAngle();
-  Square component() => Square(angle: randomAngle());
+  const double angleArgument = 6.0;
+  TestComponent component() => TestComponent(angle: 0.5);
 
   RotateEffect effect(bool isInfinite, bool isAlternating) {
     return RotateEffect(
       angle: angleArgument,
-      duration: random.nextInt(100).toDouble(),
+      duration: 1 + random.nextInt(100).toDouble(),
       isInfinite: isInfinite,
       isAlternating: isAlternating,
     );
   }
 
   testWidgets('RotateEffect can rotate', (WidgetTester tester) async {
-    final RotateEffect rotateEffect = effect(false, false);
     effectTest(
       tester,
       component(),
-      rotateEffect,
+      effect(false, false),
       expectedAngle: angleArgument,
     );
   });
@@ -40,11 +31,10 @@ void main() {
   testWidgets(
     'RotateEffect will stop rotating after it is done',
     (WidgetTester tester) async {
-      final RotateEffect rotateEffect = effect(false, false);
       effectTest(
         tester,
         component(),
-        rotateEffect,
+        effect(false, false),
         expectedAngle: angleArgument,
         iterations: 1.5,
       );
@@ -52,12 +42,11 @@ void main() {
   );
 
   testWidgets('RotateEffect can alternate', (WidgetTester tester) async {
-    final RotateEffect rotateEffect = effect(false, true);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      rotateEffect,
+      effect(false, true),
       expectedAngle: positionComponent.angle,
     );
   });
@@ -65,12 +54,11 @@ void main() {
   testWidgets(
     'RotateEffect can alternate and be infinite',
     (WidgetTester tester) async {
-      final RotateEffect rotateEffect = effect(true, true);
       final PositionComponent positionComponent = component();
       effectTest(
         tester,
         positionComponent,
-        rotateEffect,
+        effect(true, true),
         expectedAngle: positionComponent.angle,
         iterations: 1.0,
         shouldFinish: false,
@@ -79,12 +67,11 @@ void main() {
   );
 
   testWidgets('RotateEffect alternation can peak', (WidgetTester tester) async {
-    final RotateEffect rotateEffect = effect(false, true);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      rotateEffect,
+      effect(false, true),
       expectedAngle: angleArgument,
       shouldFinish: false,
       iterations: 0.5,
@@ -92,12 +79,11 @@ void main() {
   });
 
   testWidgets('RotateEffect can be infinite', (WidgetTester tester) async {
-    final RotateEffect rotateEffect = effect(true, false);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      rotateEffect,
+      effect(true, false),
       expectedAngle: angleArgument,
       iterations: 3.0,
       shouldFinish: false,

test/effects/scale_effect_test.dart

@@ -11,23 +11,22 @@ void main() {
   final Random random = Random();
   Vector2 randomVector2() => (Vector2.random(random) * 100)..round();
   final Vector2 argumentSize = randomVector2();
-  Square component() => Square(size: randomVector2());
+  TestComponent component() => TestComponent(size: randomVector2());
 
   ScaleEffect effect(bool isInfinite, bool isAlternating) {
     return ScaleEffect(
       size: argumentSize,
-      duration: random.nextInt(100).toDouble(),
+      duration: 1 + random.nextInt(100).toDouble(),
       isInfinite: isInfinite,
       isAlternating: isAlternating,
     );
   }
 
   testWidgets('ScaleEffect can scale', (WidgetTester tester) async {
-    final ScaleEffect scaleEffect = effect(false, false);
     effectTest(
       tester,
       component(),
-      scaleEffect,
+      effect(false, false),
       expectedSize: argumentSize,
     );
   });
@@ -35,11 +34,10 @@ void main() {
   testWidgets(
     'ScaleEffect will stop scaling after it is done',
     (WidgetTester tester) async {
-      final ScaleEffect scaleEffect = effect(false, false);
       effectTest(
         tester,
         component(),
-        scaleEffect,
+        effect(false, false),
         expectedSize: argumentSize,
         iterations: 1.5,
       );
@@ -47,12 +45,11 @@ void main() {
   );
 
   testWidgets('ScaleEffect can alternate', (WidgetTester tester) async {
-    final ScaleEffect scaleEffect = effect(false, true);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      scaleEffect,
+      effect(false, true),
       expectedSize: positionComponent.size.clone(),
     );
   });
@@ -60,12 +57,11 @@ void main() {
   testWidgets(
     'ScaleEffect can alternate and be infinite',
     (WidgetTester tester) async {
-      final ScaleEffect scaleEffect = effect(true, true);
       final PositionComponent positionComponent = component();
       effectTest(
         tester,
         positionComponent,
-        scaleEffect,
+        effect(true, true),
         expectedSize: positionComponent.size.clone(),
         iterations: 1.0,
         shouldFinish: false,
@@ -74,12 +70,11 @@ void main() {
   );
 
   testWidgets('ScaleEffect alternation can peak', (WidgetTester tester) async {
-    final ScaleEffect scaleEffect = effect(false, true);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      scaleEffect,
+      effect(false, true),
       expectedSize: argumentSize,
       shouldFinish: false,
       iterations: 0.5,
@@ -87,12 +82,11 @@ void main() {
   });
 
   testWidgets('ScaleEffect can be infinite', (WidgetTester tester) async {
-    final ScaleEffect scaleEffect = effect(true, false);
     final PositionComponent positionComponent = component();
     effectTest(
       tester,
       positionComponent,
-      scaleEffect,
+      effect(true, false),
       expectedSize: argumentSize,
       iterations: 3.0,
       shouldFinish: false,