Merge branch 'main' into release

lib/game/behaviors/animatronic_looping_behavior.dart

@@ -0,0 +1,26 @@
+import 'package:flame/components.dart';
+import 'package:pinball_flame/pinball_flame.dart';
+
+class AnimatronicLoopingBehavior extends TimerComponent
+    with ParentIsA<SpriteAnimationComponent> {
+  AnimatronicLoopingBehavior({
+    required double animationCoolDown,
+  }) : super(period: animationCoolDown);
+
+  @override
+  Future<void> onLoad() async {
+    await super.onLoad();
+    parent.animation?.onComplete = () {
+      parent.animation?.reset();
+      parent.playing = false;
+      timer
+        ..reset()
+        ..start();
+    };
+  }
+
+  @override
+  void onTick() {
+    parent.playing = true;
+  }
+}

lib/game/behaviors/behaviors.dart

@@ -1,3 +1,4 @@
+export 'animatronic_looping_behavior.dart';
 export 'ball_spawning_behavior.dart';
 export 'bonus_ball_spawning_behavior.dart';
 export 'bonus_noise_behavior.dart';

lib/game/components/flutter_forest/behaviors/flutter_forest_bonus_behavior.dart

@@ -21,7 +21,6 @@ class FlutterForestBonusBehavior extends Component
 
     final bumpers = parent.children.whereType<DashBumper>();
     final signpost = parent.firstChild<Signpost>()!;
-    final animatronic = parent.firstChild<DashAnimatronic>()!;
 
     for (final bumper in bumpers) {
       bumper.bloc.stream.listen((state) {
@@ -38,7 +37,6 @@ class FlutterForestBonusBehavior extends Component
           if (signpost.bloc.isFullyProgressed()) {
             bloc.add(const BonusActivated(GameBonus.dashNest));
             add(BonusBallSpawningBehavior());
-            animatronic.playing = true;
             signpost.bloc.onProgressed();
           }
         }

lib/game/components/flutter_forest/flutter_forest.dart

@@ -40,7 +40,11 @@ class FlutterForest extends Component with ZIndex {
                 BumperNoiseBehavior(),
               ],
             )..initialPosition = Vector2(21.8, -46.75),
-            DashAnimatronic()..position = Vector2(20, -66),
+            DashAnimatronic(
+              children: [
+                AnimatronicLoopingBehavior(animationCoolDown: 4),
+              ],
+            )..position = Vector2(20, -66),
             FlutterForestBonusBehavior(),
           ],
         ) {

lib/game/components/game_bloc_status_listener.dart

@@ -61,6 +61,11 @@ class GameBlocStatusListener extends Component
         .single
         .bloc
         .onReset();
+    gameRef
+        .descendants()
+        .whereType<DashBumper>()
+        .forEach((bumper) => bumper.bloc.onReset());
+    gameRef.descendants().whereType<Signpost>().single.bloc.onReset();
   }
 
   void _addPlungerBehaviors(Plunger plunger) {

lib/game/components/sparky_scorch/behaviors/sparky_computer_bonus_behavior.dart

@@ -12,13 +12,11 @@ class SparkyComputerBonusBehavior extends Component
   void onMount() {
     super.onMount();
     final sparkyComputer = parent.firstChild<SparkyComputer>()!;
-    final animatronic = parent.firstChild<SparkyAnimatronic>()!;
     sparkyComputer.bloc.stream.listen((state) async {
       final listenWhen = state == SparkyComputerState.withBall;
       if (!listenWhen) return;
 
       bloc.add(const BonusActivated(GameBonus.sparkyTurboCharge));
-      animatronic.playing = true;
     });
   }
 }

lib/game/components/sparky_scorch/sparky_scorch.dart

@@ -33,7 +33,11 @@ class SparkyScorch extends Component {
                 BumperNoiseBehavior(),
               ],
             )..initialPosition = Vector2(-3.3, -52.55),
-            SparkyAnimatronic()..position = Vector2(-14, -58.2),
+            SparkyAnimatronic(
+              children: [
+                AnimatronicLoopingBehavior(animationCoolDown: 3),
+              ],
+            )..position = Vector2(-14, -58.2),
             SparkyComputer(
               children: [
                 ScoringContactBehavior(points: Points.twoHundredThousand)

packages/pinball_audio/lib/gen/assets.gen.dart

@@ -20,6 +20,7 @@ class $AssetsSfxGen {
   String get cowMoo => 'assets/sfx/cow_moo.mp3';
   String get dash => 'assets/sfx/dash.mp3';
   String get dino => 'assets/sfx/dino.mp3';
+  String get flipper => 'assets/sfx/flipper.mp3';
   String get gameOverVoiceOver => 'assets/sfx/game_over_voice_over.mp3';
   String get google => 'assets/sfx/google.mp3';
   String get ioPinballVoiceOver => 'assets/sfx/io_pinball_voice_over.mp3';

packages/pinball_audio/lib/src/pinball_audio.dart

@@ -39,14 +39,17 @@ enum PinballAudio {
   /// Sparky.
   sparky,
 
-  /// Android
+  /// Android.
   android,
 
-  /// Dino
+  /// Dino.
   dino,
 
-  /// Dash
+  /// Dash.
   dash,
+
+  /// Flipper.
+  flipper,
 }
 
 /// Defines the contract of the creation of an [AudioPool].
@@ -147,6 +150,31 @@ class _SingleLoopAudio extends _LoopAudio {
   }
 }
 
+class _SingleAudioPool extends _Audio {
+  _SingleAudioPool({
+    required this.path,
+    required this.createAudioPool,
+    required this.maxPlayers,
+  });
+
+  final String path;
+  final CreateAudioPool createAudioPool;
+  final int maxPlayers;
+  late AudioPool pool;
+
+  @override
+  Future<void> load() async {
+    pool = await createAudioPool(
+      prefixFile(path),
+      maxPlayers: maxPlayers,
+      prefix: '',
+    );
+  }
+
+  @override
+  void play() => pool.start();
+}
+
 class _RandomABAudio extends _Audio {
   _RandomABAudio({
     required this.createAudioPool,
@@ -277,6 +305,11 @@ class PinballAudioPlayer {
         path: Assets.sfx.rollover,
         volume: 0.3,
       ),
+      PinballAudio.flipper: _SingleAudioPool(
+        path: Assets.sfx.flipper,
+        createAudioPool: _createAudioPool,
+        maxPlayers: 2,
+      ),
       PinballAudio.ioPinballVoiceOver: _SimplePlayAudio(
         preCacheSingleAudio: _preCacheSingleAudio,
         playSingleAudio: _playSingleAudio,

packages/pinball_audio/test/src/pinball_audio_test.dart

@@ -145,6 +145,20 @@ void main() {
         ).called(1);
       });
 
+      test('creates the flipper pool', () async {
+        await Future.wait(
+          audioPlayer.load().map((loadableBuilder) => loadableBuilder()),
+        );
+
+        verify(
+          () => createAudioPool.onCall(
+            'packages/pinball_audio/${Assets.sfx.flipper}',
+            maxPlayers: 2,
+            prefix: '',
+          ),
+        ).called(1);
+      });
+
       test('configures the audio cache instance', () async {
         await Future.wait(
           audioPlayer.load().map((loadableBuilder) => loadableBuilder()),
@@ -327,6 +341,33 @@ void main() {
       });
     });
 
+    group('flipper', () {
+      late AudioPool pool;
+
+      setUp(() {
+        pool = _MockAudioPool();
+        when(() => pool.start(volume: any(named: 'volume')))
+            .thenAnswer((_) async => () {});
+        when(
+          () => createAudioPool.onCall(
+            'packages/pinball_audio/${Assets.sfx.flipper}',
+            maxPlayers: any(named: 'maxPlayers'),
+            prefix: any(named: 'prefix'),
+          ),
+        ).thenAnswer((_) async => pool);
+      });
+
+      test('plays the flipper sound pool', () async {
+        when(seed.nextBool).thenReturn(true);
+        await Future.wait(
+          audioPlayer.load().map((loadableBuilder) => loadableBuilder()),
+        );
+        audioPlayer.play(PinballAudio.flipper);
+
+        verify(() => pool.start()).called(1);
+      });
+    });
+
     group('cow moo', () {
       test('plays the correct file', () async {
         await Future.wait(

packages/pinball_components/lib/src/components/dash_animatronic.dart

@@ -6,10 +6,11 @@ import 'package:pinball_components/pinball_components.dart';
 /// {@endtemplate}
 class DashAnimatronic extends SpriteAnimationComponent with HasGameRef {
   /// {@macro dash_animatronic}
-  DashAnimatronic()
+  DashAnimatronic({Iterable<Component>? children})
       : super(
           anchor: Anchor.center,
           playing: false,
+          children: children,
         );
 
   @override
@@ -37,9 +38,6 @@ class DashAnimatronic extends SpriteAnimationComponent with HasGameRef {
         textureSize: textureSize,
         loop: false,
       ),
-    )..onComplete = () {
+    );
-        animation?.reset();
-        playing = false;
-      };
   }
 }

packages/pinball_components/lib/src/components/flipper/behaviors/behaviors.dart

@@ -1,3 +1,4 @@
 export 'flipper_jointing_behavior.dart';
 export 'flipper_key_controlling_behavior.dart';
 export 'flipper_moving_behavior.dart';
+export 'flipper_noise_behavior.dart';

packages/pinball_components/lib/src/components/flipper/behaviors/flipper_moving_behavior.dart

@@ -15,7 +15,9 @@ class FlipperMovingBehavior extends Component
 
   late final Flipper _flipper;
 
-  void _moveUp() => _flipper.body.linearVelocity = Vector2(0, -_strength);
+  void _moveUp() {
+    _flipper.body.linearVelocity = Vector2(0, -_strength);
+  }
 
   void _moveDown() => _flipper.body.linearVelocity = Vector2(0, _strength);
 

packages/pinball_components/lib/src/components/flipper/behaviors/flipper_noise_behavior.dart

@@ -0,0 +1,18 @@
+import 'package:flame/components.dart';
+import 'package:flame_bloc/flame_bloc.dart';
+import 'package:pinball_audio/pinball_audio.dart';
+import 'package:pinball_components/pinball_components.dart';
+import 'package:pinball_flame/pinball_flame.dart';
+
+class FlipperNoiseBehavior extends Component
+    with
+        FlameBlocListenable<FlipperCubit, FlipperState>,
+        FlameBlocReader<FlipperCubit, FlipperState> {
+  @override
+  void onNewState(FlipperState state) {
+    super.onNewState(state);
+    if (bloc.state.isMovingUp) {
+      readProvider<PinballAudioPlayer>().play(PinballAudio.flipper);
+    }
+  }
+}

packages/pinball_components/lib/src/components/flipper/flipper.dart

@@ -25,7 +25,10 @@ class Flipper extends BodyComponent with KeyboardHandler, InitialPosition {
             FlipperJointingBehavior(),
             FlameBlocProvider<FlipperCubit, FlipperState>(
               create: FlipperCubit.new,
-              children: [FlipperMovingBehavior(strength: 90)],
+              children: [
+                FlipperMovingBehavior(strength: 90),
+                FlipperNoiseBehavior(),
+              ],
             ),
           ],
         );

packages/pinball_components/lib/src/components/signpost/cubit/signpost_cubit.dart

@@ -12,5 +12,7 @@ class SignpostCubit extends Cubit<SignpostState> {
     );
   }
 
+  void onReset() => emit(SignpostState.inactive);
+
   bool isFullyProgressed() => state == SignpostState.active3;
 }

packages/pinball_components/lib/src/components/sparky_animatronic.dart

@@ -8,10 +8,11 @@ import 'package:pinball_flame/pinball_flame.dart';
 class SparkyAnimatronic extends SpriteAnimationComponent
     with HasGameRef, ZIndex {
   /// {@macro sparky_animatronic}
-  SparkyAnimatronic()
+  SparkyAnimatronic({Iterable<Component>? children})
       : super(
           anchor: Anchor.center,
           playing: false,
+          children: children,
         ) {
     zIndex = ZIndexes.sparkyAnimatronic;
   }
@@ -41,9 +42,6 @@ class SparkyAnimatronic extends SpriteAnimationComponent
         textureSize: textureSize,
         loop: false,
       ),
-    )..onComplete = () {
+    );
-        animation?.reset();
-        playing = false;
-      };
   }
 }

packages/pinball_components/test/src/components/dash_animatronic_test.dart

@@ -1,6 +1,6 @@
 // ignore_for_file: cascade_invocations
 
-import 'package:flame/extensions.dart';
+import 'package:flame/components.dart';
 import 'package:flame_test/flame_test.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:pinball_components/pinball_components.dart';
@@ -56,17 +56,13 @@ void main() {
       },
     );
 
-    flameTester.test(
+    flameTester.test('adds new children', (game) async {
-      'stops animating after animation completes',
+      final component = Component();
-      (game) async {
+      final dashAnimatronic = DashAnimatronic(
-        final dashAnimatronic = DashAnimatronic();
+        children: [component],
-        await game.ensureAdd(dashAnimatronic);
+      );
-
+      await game.ensureAdd(dashAnimatronic);
-        dashAnimatronic.playing = true;
+      expect(dashAnimatronic.children, contains(component));
-        game.update(4);
+    });
-
-        expect(dashAnimatronic.playing, isFalse);
-      },
-    );
   });
 }

packages/pinball_components/test/src/components/flipper/behaviors/flipper_moving_behavior_test.dart

@@ -8,12 +8,14 @@ import 'package:flame_forge2d/flame_forge2d.dart';
 import 'package:flame_test/flame_test.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:mocktail/mocktail.dart';
+import 'package:pinball_audio/pinball_audio.dart';
 import 'package:pinball_components/pinball_components.dart';
 
 class _TestGame extends Forge2DGame {
   Future<void> pump(
     FlipperMovingBehavior behavior, {
     FlipperCubit? flipperBloc,
+    PinballAudioPlayer? audioPlayer,
   }) async {
     final flipper = Flipper.test(side: BoardSide.left);
     await ensureAdd(flipper);

packages/pinball_components/test/src/components/flipper/behaviors/flipper_noise_behavior_test.dart

@@ -0,0 +1,79 @@
+// ignore_for_file: avoid_dynamic_calls, cascade_invocations
+
+import 'dart:async';
+
+import 'package:bloc_test/bloc_test.dart';
+import 'package:flame_bloc/flame_bloc.dart';
+import 'package:flame_forge2d/flame_forge2d.dart';
+import 'package:flame_test/flame_test.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:pinball_audio/pinball_audio.dart';
+import 'package:pinball_components/pinball_components.dart';
+import 'package:pinball_flame/pinball_flame.dart';
+
+class _TestGame extends Forge2DGame {
+  Future<void> pump(
+    FlipperNoiseBehavior behavior, {
+    FlipperCubit? flipperBloc,
+    PinballAudioPlayer? audioPlayer,
+  }) async {
+    final flipper = Flipper.test(side: BoardSide.left);
+    await ensureAdd(
+      FlameProvider<PinballAudioPlayer>.value(
+        audioPlayer ?? _MockPinballAudioPlayer(),
+        children: [
+          flipper,
+        ],
+      ),
+    );
+    await flipper.ensureAdd(
+      FlameBlocProvider<FlipperCubit, FlipperState>.value(
+        value: flipperBloc ?? FlipperCubit(),
+        children: [behavior],
+      ),
+    );
+  }
+}
+
+class _MockPinballAudioPlayer extends Mock implements PinballAudioPlayer {}
+
+class _MockFlipperCubit extends Mock implements FlipperCubit {}
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+  final flameTester = FlameTester(_TestGame.new);
+
+  group('FlipperNoiseBehavior', () {
+    test('can be instantiated', () {
+      expect(
+        FlipperNoiseBehavior(),
+        isA<FlipperNoiseBehavior>(),
+      );
+    });
+
+    flameTester.test(
+      'plays the flipper sound when moving up',
+      (game) async {
+        final audioPlayer = _MockPinballAudioPlayer();
+        final bloc = _MockFlipperCubit();
+        whenListen(
+          bloc,
+          Stream.fromIterable([FlipperState.movingUp]),
+          initialState: FlipperState.movingUp,
+        );
+
+        final behavior = FlipperNoiseBehavior();
+        await game.pump(
+          behavior,
+          flipperBloc: bloc,
+          audioPlayer: audioPlayer,
+        );
+        behavior.onNewState(FlipperState.movingUp);
+        game.update(0);
+
+        verify(() => audioPlayer.play(PinballAudio.flipper)).called(1);
+      },
+    );
+  });
+}

packages/pinball_components/test/src/components/signpost/cubit/signpost_cubit_test.dart

@@ -22,6 +22,13 @@ void main() {
       ],
     );
 
+    blocTest<SignpostCubit, SignpostState>(
+      'onReset emits inactive',
+      build: SignpostCubit.new,
+      act: (bloc) => bloc.onReset(),
+      expect: () => [SignpostState.inactive],
+    );
+
     test('isFullyProgressed when on active3', () {
       final bloc = SignpostCubit();
       expect(bloc.isFullyProgressed(), isFalse);

packages/pinball_components/test/src/components/sparky_animatronic_test.dart

@@ -1,6 +1,6 @@
 // ignore_for_file: cascade_invocations
 
-import 'package:flame/extensions.dart';
+import 'package:flame/components.dart';
 import 'package:flame_test/flame_test.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:pinball_components/pinball_components.dart';
@@ -58,19 +58,13 @@ void main() {
       },
     );
 
-    flameTester.test(
+    flameTester.test('adds new children', (game) async {
-      'stops animating after animation completes',
+      final component = Component();
-      (game) async {
+      final sparkyAnimatronic = SparkyAnimatronic(
-        final sparkyAnimatronic = SparkyAnimatronic();
+        children: [component],
-        await game.ensureAdd(sparkyAnimatronic);
+      );
-
+      await game.ensureAdd(sparkyAnimatronic);
-        sparkyAnimatronic.playing = true;
+      expect(sparkyAnimatronic.children, contains(component));
-        final animationDuration =
+    });
-            game.firstChild<SparkyAnimatronic>()!.animation!.totalDuration();
-        game.update(animationDuration);
-
-        expect(sparkyAnimatronic.playing, isFalse);
-      },
-    );
   });
 }

test/game/behaviors/animatronic_looping_behavior_test.dart

@@ -0,0 +1,105 @@
+// ignore_for_file: cascade_invocations
+
+import 'package:flame/components.dart';
+import 'package:flame_forge2d/flame_forge2d.dart';
+import 'package:flame_test/flame_test.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:mocktail/mocktail.dart';
+import 'package:pinball/game/behaviors/behaviors.dart';
+import 'package:pinball_components/pinball_components.dart';
+
+class _TestGame extends Forge2DGame {
+  @override
+  Future<void> onLoad() async {
+    images.prefix = '';
+    await images.load(Assets.images.dash.animatronic.keyName);
+  }
+}
+
+class _TestSpriteAnimationComponent extends SpriteAnimationComponent {}
+
+class _MockSpriteAnimation extends Mock implements SpriteAnimation {}
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  final flameTester = FlameTester(_TestGame.new);
+
+  group('AnimatronicLoopingBehavior', () {
+    test('can be instantiated', () {
+      expect(
+        AnimatronicLoopingBehavior(animationCoolDown: 1),
+        isA<AnimatronicLoopingBehavior>(),
+      );
+    });
+
+    flameTester.test(
+      'can be added',
+      (game) async {
+        final behavior = AnimatronicLoopingBehavior(animationCoolDown: 1);
+        final animation = _MockSpriteAnimation();
+        final spriteAnimationComponent = _TestSpriteAnimationComponent()
+          ..animation = animation;
+        await game.ensureAdd(spriteAnimationComponent);
+        await spriteAnimationComponent.add(behavior);
+        await game.ready();
+
+        expect(game.contains(spriteAnimationComponent), isTrue);
+        expect(spriteAnimationComponent.contains(behavior), isTrue);
+      },
+    );
+
+    flameTester.test(
+      'onTick starts playing the animation',
+      (game) async {
+        final behavior = AnimatronicLoopingBehavior(animationCoolDown: 1);
+        final spriteAnimationComponent = _TestSpriteAnimationComponent();
+        await game.ensureAdd(spriteAnimationComponent);
+        await spriteAnimationComponent.add(behavior);
+
+        spriteAnimationComponent.playing = false;
+        game.update(behavior.timer.limit);
+
+        expect(spriteAnimationComponent.playing, isTrue);
+      },
+    );
+
+    flameTester.test(
+      'animation onComplete resets and stops playing the animation',
+      (game) async {
+        final behavior = AnimatronicLoopingBehavior(animationCoolDown: 1);
+        final spriteAnimationComponent = DashAnimatronic();
+
+        await game.ensureAdd(spriteAnimationComponent);
+        await spriteAnimationComponent.add(behavior);
+
+        game.update(1);
+        expect(spriteAnimationComponent.playing, isTrue);
+
+        spriteAnimationComponent.animation!.onComplete!.call();
+
+        expect(spriteAnimationComponent.playing, isFalse);
+        expect(spriteAnimationComponent.animation!.currentIndex, equals(0));
+      },
+    );
+
+    flameTester.test(
+      'animation onComplete resets and starts the timer',
+      (game) async {
+        final behavior = AnimatronicLoopingBehavior(animationCoolDown: 1);
+        final spriteAnimationComponent = DashAnimatronic();
+
+        await game.ensureAdd(spriteAnimationComponent);
+        await spriteAnimationComponent.add(behavior);
+
+        game.update(0.5);
+        expect(behavior.timer.current, equals(0.5));
+
+        spriteAnimationComponent.animation!.onComplete!.call();
+
+        expect(behavior.timer.current, equals(0));
+        expect(behavior.timer.isRunning(), isTrue);
+      },
+    );
+  });
+}

test/game/components/flutter_forest/behaviors/flutter_forest_bonus_behavior_test.dart

@@ -16,10 +16,7 @@ class _TestGame extends Forge2DGame {
   @override
   Future<void> onLoad() async {
     images.prefix = '';
-    await images.loadAll([
+    await images.load(theme.Assets.images.dash.ball.keyName);
-      Assets.images.dash.animatronic.keyName,
-      theme.Assets.images.dash.ball.keyName,
-    ]);
   }
 
   Future<void> pump(
@@ -67,10 +64,9 @@ void main() {
           DashBumper.test(bloc: DashBumperCubit()),
           DashBumper.test(bloc: DashBumperCubit()),
         ];
-        final animatronic = DashAnimatronic();
         final signpost = Signpost.test(bloc: SignpostCubit());
         await game.pump(parent, gameBloc: gameBloc);
-        await parent.ensureAddAll([...bumpers, animatronic, signpost]);
+        await parent.ensureAddAll([...bumpers, signpost]);
         await parent.ensureAdd(behavior);
 
         expect(game.descendants().whereType<DashBumper>(), equals(bumpers));
@@ -99,10 +95,9 @@ void main() {
           DashBumper.test(bloc: DashBumperCubit()),
           DashBumper.test(bloc: DashBumperCubit()),
         ];
-        final animatronic = DashAnimatronic();
         final signpost = Signpost.test(bloc: SignpostCubit());
         await game.pump(parent, gameBloc: gameBloc);
-        await parent.ensureAddAll([...bumpers, animatronic, signpost]);
+        await parent.ensureAddAll([...bumpers, signpost]);
         await parent.ensureAdd(behavior);
 
         expect(game.descendants().whereType<DashBumper>(), equals(bumpers));
@@ -133,10 +128,9 @@ void main() {
           DashBumper.test(bloc: DashBumperCubit()),
           DashBumper.test(bloc: DashBumperCubit()),
         ];
-        final animatronic = DashAnimatronic();
         final signpost = Signpost.test(bloc: SignpostCubit());
         await game.pump(parent, gameBloc: gameBloc);
-        await parent.ensureAddAll([...bumpers, animatronic, signpost]);
+        await parent.ensureAddAll([...bumpers, signpost]);
         await parent.ensureAdd(behavior);
 
         expect(game.descendants().whereType<DashBumper>(), equals(bumpers));

test/game/components/game_bloc_status_listener_test.dart

@@ -86,6 +86,10 @@ class _MockPlungerCubit extends Mock implements PlungerCubit {}
 
 class _MockGoogleWordCubit extends Mock implements GoogleWordCubit {}
 
+class _MockDashBumperCubit extends Mock implements DashBumperCubit {}
+
+class _MockSignpostCubit extends Mock implements SignpostCubit {}
+
 class _MockFlipperCubit extends Mock implements FlipperCubit {}
 
 class _MockAppLocalizations extends Mock implements AppLocalizations {
@@ -332,7 +336,15 @@ void main() {
           (game) async {
             final audioPlayer = _MockPinballAudioPlayer();
             final component = GameBlocStatusListener();
-            await game.pump([component], pinballAudioPlayer: audioPlayer);
+            await game.pump(
+              [
+                component,
+                Signpost.test(
+                  bloc: _MockSignpostCubit(),
+                ),
+              ],
+              pinballAudioPlayer: audioPlayer,
+            );
 
             expect(state.status, equals(GameStatus.playing));
             component.onNewState(state);
@@ -350,7 +362,15 @@ void main() {
           (game) async {
             final googleWordBloc = _MockGoogleWordCubit();
             final component = GameBlocStatusListener();
-            await game.pump([component], googleWordBloc: googleWordBloc);
+            await game.pump(
+              [
+                component,
+                Signpost.test(
+                  bloc: _MockSignpostCubit(),
+                ),
+              ],
+              googleWordBloc: googleWordBloc,
+            );
 
             expect(state.status, equals(GameStatus.playing));
             component.onNewState(state);
@@ -359,6 +379,46 @@ void main() {
           },
         );
 
+        flameTester.test(
+          'resets the DashBumperCubits',
+          (game) async {
+            final dashBumper1Bloc = _MockDashBumperCubit();
+            final dashBumper2Bloc = _MockDashBumperCubit();
+            final dashBumper1 = DashBumper.test(bloc: dashBumper1Bloc);
+            final dashBumper2 = DashBumper.test(bloc: dashBumper2Bloc);
+            final component = GameBlocStatusListener();
+            await game.pump([
+              component,
+              dashBumper1,
+              dashBumper2,
+              Signpost.test(
+                bloc: _MockSignpostCubit(),
+              ),
+            ]);
+
+            expect(state.status, equals(GameStatus.playing));
+            component.onNewState(state);
+
+            verify(dashBumper1Bloc.onReset).called(1);
+            verify(dashBumper2Bloc.onReset).called(1);
+          },
+        );
+
+        flameTester.test(
+          'resets the SignpostCubit',
+          (game) async {
+            final signpostBloc = _MockSignpostCubit();
+            final signpost = Signpost.test(bloc: signpostBloc);
+            final component = GameBlocStatusListener();
+            await game.pump([component, signpost]);
+
+            expect(state.status, equals(GameStatus.playing));
+            component.onNewState(state);
+
+            verify(signpostBloc.onReset).called(1);
+          },
+        );
+
         flameTester.test(
           'adds FlipperKeyControllingBehavior to Flippers',
           (game) async {
@@ -372,7 +432,14 @@ void main() {
             );
             final flipper = Flipper.test(side: BoardSide.left);
 
-            await game.pump([component, backbox, flipper]);
+            await game.pump([
+              component,
+              backbox,
+              flipper,
+              Signpost.test(
+                bloc: _MockSignpostCubit(),
+              ),
+            ]);
             await flipper.ensureAdd(
               FlameBlocProvider<FlipperCubit, FlipperState>(
                 create: _MockFlipperCubit.new,
@@ -407,7 +474,14 @@ void main() {
             );
             final plunger = Plunger.test();
             await game.pump(
-              [component, backbox, plunger],
+              [
+                component,
+                backbox,
+                plunger,
+                Signpost.test(
+                  bloc: _MockSignpostCubit(),
+                ),
+              ],
               platformHelper: platformHelper,
             );
             await plunger.ensureAdd(
@@ -446,7 +520,14 @@ void main() {
             );
             final plunger = Plunger.test();
             await game.pump(
-              [component, backbox, plunger],
+              [
+                component,
+                backbox,
+                plunger,
+                Signpost.test(
+                  bloc: _MockSignpostCubit(),
+                ),
+              ],
               platformHelper: platformHelper,
             );
             await plunger.ensureAdd(
@@ -482,7 +563,14 @@ void main() {
             );
             final plunger = Plunger.test();
             await game.pump(
-              [component, backbox, plunger],
+              [
+                component,
+                backbox,
+                plunger,
+                Signpost.test(
+                  bloc: _MockSignpostCubit(),
+                ),
+              ],
               platformHelper: platformHelper,
             );
             await plunger.ensureAdd(

test/game/components/sparky_scorch/behaviors/sparky_computer_bonus_behavior_test.dart

@@ -17,7 +17,6 @@ class _TestGame extends Forge2DGame {
       Assets.images.sparky.computer.top.keyName,
       Assets.images.sparky.computer.base.keyName,
       Assets.images.sparky.computer.glow.keyName,
-      Assets.images.sparky.animatronic.keyName,
       Assets.images.sparky.bumper.a.lit.keyName,
       Assets.images.sparky.bumper.a.dimmed.keyName,
       Assets.images.sparky.bumper.b.lit.keyName,
@@ -58,18 +57,14 @@ void main() {
     final flameTester = FlameTester(_TestGame.new);
 
     flameTester.testGameWidget(
-      'adds GameBonus.sparkyTurboCharge to the game and plays animatronic '
+      'adds GameBonus.sparkyTurboCharge to the game '
       'when SparkyComputerState.withBall is emitted',
       setUp: (game, tester) async {
         final behavior = SparkyComputerBonusBehavior();
         final parent = SparkyScorch.test();
         final sparkyComputer = SparkyComputer();
-        final animatronic = SparkyAnimatronic();
 
-        await parent.addAll([
+        await parent.add(sparkyComputer);
-          sparkyComputer,
-          animatronic,
-        ]);
         await game.pump(parent, gameBloc: gameBloc);
         await parent.ensureAdd(behavior);
 
@@ -79,7 +74,6 @@ void main() {
         verify(
           () => gameBloc.add(const BonusActivated(GameBonus.sparkyTurboCharge)),
         ).called(1);
-        expect(animatronic.playing, isTrue);
       },
     );
   });