refactor: Divide TileLayer by its Layer type (#2326)

As-is

    The TileLayer became too big to maintain.
    Some tile related classes doesn't have factory method, their creation is done in other classes with big switch-case.

To-be

    Divided TileLayer into its Layer type. The Layer type is determined by MapOrientaion which has a member of isometric, orthogonal, staggered, and hexagonal.
    Instantiation is done by factory method inside the class.

packages/flame_tiled/lib/src/renderable_layers/group_layer.dart

@@ -12,12 +12,12 @@ class GroupLayer extends RenderableLayer<Group> {
   ///       there are cyclic dependencies when loading the renderable layers.
   late final List<RenderableLayer> children;
 
-  GroupLayer(
-    super.layer,
-    super.parent,
-    super.map,
-    super.destTileSize,
-  );
+  GroupLayer({
+    required super.layer,
+    required super.parent,
+    required super.map,
+    required super.destTileSize,
+  });
 
   @override
   void refreshCache() {

packages/flame_tiled/lib/src/renderable_layers/image_layer.dart

@@ -13,13 +13,13 @@ class FlameImageLayer extends RenderableLayer<ImageLayer> {
   late final ImageRepeat _repeat;
   Rect _paintArea = Rect.zero;
 
-  FlameImageLayer(
-    super.layer,
-    super.parent,
-    this._image,
-    super.map,
-    super.destTileSize,
-  ) {
+  FlameImageLayer({
+    required super.layer,
+    required super.parent,
+    required super.map,
+    required super.destTileSize,
+    required Image image,
+  }) : _image = image {
     _initImageRepeat();
   }
 
@@ -62,19 +62,19 @@ class FlameImageLayer extends RenderableLayer<ImageLayer> {
     }
   }
 
-  static Future<FlameImageLayer> load(
-    ImageLayer layer,
-    GroupLayer? parent,
-    Camera? camera,
-    TiledMap map,
-    Vector2 destTileSize,
-  ) async {
+  static Future<FlameImageLayer> load({
+    required ImageLayer layer,
+    required GroupLayer? parent,
+    required Camera? camera,
+    required TiledMap map,
+    required Vector2 destTileSize,
+  }) async {
     return FlameImageLayer(
-      layer,
-      parent,
-      await Flame.images.load(layer.image.source!),
-      map,
-      destTileSize,
+      layer: layer,
+      parent: parent,
+      map: map,
+      destTileSize: destTileSize,
+      image: await Flame.images.load(layer.image.source!),
     );
   }
 

packages/flame_tiled/lib/src/renderable_layers/object_layer.dart

@@ -6,12 +6,12 @@ import 'package:tiled/tiled.dart';
 
 @internal
 class ObjectLayer extends RenderableLayer<ObjectGroup> {
-  ObjectLayer(
-    super.layer,
-    super.parent,
-    super.map,
-    super.destTileSize,
-  );
+  ObjectLayer({
+    required super.layer,
+    required super.parent,
+    required super.map,
+    required super.destTileSize,
+  });
 
   @override
   void render(Canvas canvas, Camera? camera) {
@@ -27,7 +27,12 @@ class ObjectLayer extends RenderableLayer<ObjectGroup> {
     TiledMap map,
     Vector2 destTileSize,
   ) async {
-    return ObjectLayer(layer, null, map, destTileSize);
+    return ObjectLayer(
+      layer: layer,
+      parent: null,
+      map: map,
+      destTileSize: destTileSize,
+    );
   }
 
   @override

packages/flame_tiled/lib/src/renderable_layers/renderable_layer.dart

@@ -1,6 +1,11 @@
 import 'package:flame/extensions.dart';
 import 'package:flame/game.dart';
 import 'package:flame_tiled/src/renderable_layers/group_layer.dart';
+import 'package:flame_tiled/src/renderable_layers/image_layer.dart';
+import 'package:flame_tiled/src/renderable_layers/object_layer.dart';
+import 'package:flame_tiled/src/renderable_layers/tile_layers/tile_layer.dart';
+import 'package:flame_tiled/src/tile_animation.dart';
+import 'package:flame_tiled/src/tile_atlas.dart';
 import 'package:meta/meta.dart';
 import 'package:tiled/tiled.dart';
 
@@ -13,12 +18,65 @@ abstract class RenderableLayer<T extends Layer> {
   /// The parent [Group] layer (if it exists)
   final GroupLayer? parent;
 
-  RenderableLayer(
-    this.layer,
-    this.parent,
-    this.map,
-    this.destTileSize,
-  );
+  RenderableLayer({
+    required this.layer,
+    required this.parent,
+    required this.map,
+    required this.destTileSize,
+  });
+
+  /// [load] is a factory method to create [RenderableLayer] by type of [layer].
+  static Future<RenderableLayer> load({
+    required Layer layer,
+    required GroupLayer? parent,
+    required TiledMap map,
+    required Vector2 destTileSize,
+    required Camera? camera,
+    required Map<Tile, TileFrames> animationFrames,
+    required TiledAtlas atlas,
+    bool? ignoreFlip,
+  }) async {
+    if (layer is TileLayer) {
+      return FlameTileLayer.load(
+        layer: layer,
+        parent: parent,
+        map: map,
+        destTileSize: destTileSize,
+        animationFrames: animationFrames,
+        atlas: atlas.clone(),
+        ignoreFlip: ignoreFlip,
+      );
+    } else if (layer is ImageLayer) {
+      return FlameImageLayer.load(
+        layer: layer,
+        parent: parent,
+        camera: camera,
+        map: map,
+        destTileSize: destTileSize,
+      );
+    } else if (layer is ObjectGroup) {
+      return ObjectLayer.load(
+        layer,
+        map,
+        destTileSize,
+      );
+    } else if (layer is Group) {
+      final groupLayer = layer;
+      return GroupLayer(
+        layer: groupLayer,
+        parent: parent,
+        map: map,
+        destTileSize: destTileSize,
+      );
+    }
+
+    return UnsupportedLayer(
+      layer: layer,
+      parent: parent,
+      map: map,
+      destTileSize: destTileSize,
+    );
+  }
 
   bool get visible => layer.visible;
 
@@ -72,12 +130,12 @@ abstract class RenderableLayer<T extends Layer> {
 
 @internal
 class UnsupportedLayer extends RenderableLayer {
-  UnsupportedLayer(
-    super.layer,
-    super.parent,
-    super.map,
-    super.destTileSize,
-  );
+  UnsupportedLayer({
+    required super.layer,
+    required super.parent,
+    required super.map,
+    required super.destTileSize,
+  });
 
   @override
   void render(Canvas canvas, Camera? camera) {}