feat: Change HasCollisionDetection to be on Component

packages/flame/lib/src/collisions/has_collision_detection.dart

@@ -1,9 +1,9 @@
 import 'package:flame/collisions.dart';
-import 'package:flame/game.dart';
+import 'package:flame/components.dart';
 
 /// Keeps track of all the [ShapeHitbox]s in the component tree and initiates
 /// collision detection every tick.
-mixin HasCollisionDetection<B extends Broadphase<ShapeHitbox>> on FlameGame {
+mixin HasCollisionDetection<B extends Broadphase<ShapeHitbox>> on Component {
  CollisionDetection<ShapeHitbox, B> _collisionDetection =
  StandardCollisionDetection();
  CollisionDetection<ShapeHitbox, B> get collisionDetection =>
@@ -27,7 +27,7 @@ mixin HasCollisionDetection<B extends Broadphase<ShapeHitbox>> on FlameGame {
 /// Do note that [collisionDetection] has to be initialized before the game
 /// starts the update loop for the collision detection to work.
 mixin HasGenericCollisionDetection<T extends Hitbox<T>, B extends Broadphase<T>>
- on FlameGame {
+ on Component {
  CollisionDetection<T, B>? _collisionDetection;
  CollisionDetection<T, B> get collisionDetection => _collisionDetection!;
 

packages/flame/lib/src/collisions/hitboxes/shape_hitbox.dart

@@ -96,9 +96,9 @@ mixin ShapeHitbox on ShapeComponent implements Hitbox<ShapeHitbox> {
 
  // This should be placed after the hitbox parent listener
  // since the correct hitbox size is required by the QuadTree.
- final parentGame = findParent<FlameGame>();
- if (parentGame is HasCollisionDetection) {
- _collisionDetection = parentGame.collisionDetection;
+ final parent = findParent<HasCollisionDetection>();
+ if (parent is HasCollisionDetection) {
+ _collisionDetection = parent.collisionDetection;
  _collisionDetection?.add(this);
  }
  }

packages/flame/lib/src/components/core/component.dart

@@ -300,8 +300,11 @@ class Component {
 
  /// Returns the closest parent further up the hierarchy that satisfies type=T,
  /// or null if no such parent can be found.
- T? findParent<T extends Component>() {
- return ancestors().whereType<T>().firstOrNull;
+ ///
+ /// If [includeSelf] is set to true (default is false) then the component
+ /// which the call is made for is also included in the search.
+ T? findParent<T extends Component>({bool includeSelf = false}) {
+ return ancestors(includeSelf: includeSelf).whereType<T>().firstOrNull;
  }
 
  /// Returns the first child that matches the given type [T], or null if there

packages/flame/test/collisions/collision_callback_benchmark_test.dart

@@ -2,6 +2,7 @@ import 'dart:math';
 
 import 'package:flame/collisions.dart';
 import 'package:flame/components.dart';
+import 'package:flame/game.dart';
 import 'package:flame_test/flame_test.dart';
 import 'package:test/test.dart';
 
@@ -41,7 +42,8 @@ class _TestBlock extends PositionComponent with CollisionCallbacks {
 void main() {
  group('Benchmark collision detection', () {
  runCollisionTestRegistry({
- 'collidable callbacks are called': (game) async {
+ 'collidable callbacks are called': (collisionSystem) async {
+ final game = collisionSystem as FlameGame;
  final rng = Random(0);
  final blocks = List.generate(
  100,

packages/flame/test/collisions/collision_callback_test.dart

@@ -1,5 +1,7 @@
 import 'package:flame/collisions.dart';
 import 'package:flame/components.dart';
+import 'package:flame/experimental.dart';
+import 'package:flame/game.dart';
 import 'package:flame_test/flame_test.dart';
 import 'package:test/test.dart';
 
@@ -463,7 +465,8 @@ void main() {
  expect(player.endCounter, 0);
  },
  // Reproduced #1478
- 'collision callbacks with changed game size': (game) async {
+ 'collision callbacks with changed game size': (collisionSystem) async {
+ final game = collisionSystem as FlameGame;
  final block = TestBlock(Vector2.all(20), Vector2.all(10))
  ..anchor = Anchor.center;
  await game.ensureAddAll([ScreenHitbox(), block]);
@@ -512,6 +515,46 @@ void main() {
  expect(outerBlock.onCollisionCounter, 1);
  expect(outerBlock.endCounter, 1);
  },
+ 'collision callbacks for nested World': (outerCollisionSystem) async {
+ final game = outerCollisionSystem as FlameGame;
+ final world1 = CollisionDetectionWorld();
+ final world2 = CollisionDetectionWorld();
+ final camera1 = CameraComponent(world: world1);
+ final camera2 = CameraComponent(world: world2);
+ await game.ensureAddAll([world1, world2, camera1, camera2]);
+ final block1 = TestBlock(Vector2(1, 1), Vector2.all(2))
+ ..anchor = Anchor.center;
+ final block2 = TestBlock(Vector2(1, -1), Vector2.all(2))
+ ..anchor = Anchor.center;
+ final block3 = TestBlock(Vector2(-1, 1), Vector2.all(2))
+ ..anchor = Anchor.center;
+ final block4 = TestBlock(Vector2(-1, -1), Vector2.all(2))
+ ..anchor = Anchor.center;
+ await world1.ensureAddAll([block1, block2]);
+ await world2.ensureAddAll([block3, block4]);
+
+ game.update(0);
+ for (final block in [block1, block2, block3, block4]) {
+ expect(block.startCounter, 1);
+ expect(block.onCollisionCounter, 1);
+ expect(block.endCounter, 0);
+ }
+ expect(block1.collidedWithExactly([block2]), isTrue);
+ expect(block2.collidedWithExactly([block1]), isTrue);
+ expect(block3.collidedWithExactly([block4]), isTrue);
+ expect(block4.collidedWithExactly([block3]), isTrue);
+
+ for (final block in [block1, block2, block3, block4]) {
+ block.position.scale(3);
+ }
+
+ game.update(0);
+ for (final block in [block1, block2, block3, block4]) {
+ expect(block.startCounter, 1);
+ expect(block.onCollisionCounter, 1);
+ expect(block.endCounter, 1);
+ }
+ },
  });
 
  group('ComponentTypeCheck(only supported in the QuadTree)', () {