fix(texturepacker): improve path resolution and region parsing #3848

Author: s1r1m1r1

packages/flame_texturepacker/lib/src/texture_packer_atlas.dart

@@ -262,9 +262,31 @@ Future<TextureAtlasData> _parse(
       }
     }
 
+    var currentPackage = package;
+    var finalPath = fullPath;
+
+    // Check for package path in the full path (which may already include assetsPrefix)
+    const packageKeyword = 'packages/';
+    final packageIndex = finalPath.indexOf(packageKeyword);
+    if (packageIndex != -1) {
+      final subPath = finalPath.substring(packageIndex + packageKeyword.length);
+      final parts = subPath.split('/');
+      if (parts.length > 1) {
+        currentPackage ??= parts[0];
+        // Clean the path by removing everything up to and including the package name
+        finalPath = parts.sublist(1).join('/');
+      }
+    }
+
+    // AssetsCache also prepends its own prefix (usually 'assets/')
+    final assetsCachePrefix = (assets ?? Flame.assets).prefix;
+    if (finalPath.startsWith(assetsCachePrefix)) {
+      finalPath = finalPath.replaceFirst(assetsCachePrefix, '');
+    }
+
     fileContent = await (assets ?? Flame.assets).readFile(
-      fullPath,
-      package: package,
+      finalPath,
+      package: currentPackage,
     );
   }
 
@@ -293,6 +315,30 @@ Future<TextureAtlasData> _parse(
 
       // Check if this line looks like a texture file (has file extension)
       if (_isTextureFile(line)) {
+        // Peek at the next line to see if it's a region or a new page.
+        // Regions are followed by properties like 'bounds:', 'rotate:', 'xy:', 'offsets:'.
+        // Pages are followed by 'size:', 'format:', 'filter:', 'repeat:'.
+        if (lineQueue.length > 1) {
+          final nextLine = lineQueue.elementAt(1).trim();
+          final isRegionProperty =
+              nextLine.startsWith('bounds:') ||
+              nextLine.startsWith('rotate:') ||
+              nextLine.startsWith('xy:') ||
+              nextLine.startsWith('offsets:') ||
+              nextLine.startsWith('orig:') ||
+              nextLine.startsWith('offset:') ||
+              nextLine.startsWith('index:');
+
+          if (isRegionProperty) {
+            // This is a region name that happens to have a file extension.
+            final region = _parseRegion(lineQueue, page);
+            if (region.index != -1) {
+              hasIndexes = true;
+            }
+            regions.add(region);
+            continue;
+          }
+        }
         break; // This is a new page, break out of region parsing
       }
 
@@ -388,7 +434,29 @@ Future<Page> _parsePage(
       }
     }
 
-    page.texture = await images.load(fullTexturePath, package: package);
+    var currentPackage = package;
+    var finalTexturePath = fullTexturePath;
+
+    const packageKeyword = 'packages/';
+    final packageIndex = finalTexturePath.indexOf(packageKeyword);
+    if (packageIndex != -1) {
+      final subPath = finalTexturePath.substring(
+        packageIndex + packageKeyword.length,
+      );
+      final parts = subPath.split('/');
+      if (parts.length > 1) {
+        currentPackage ??= parts[0];
+        finalTexturePath = parts.sublist(1).join('/');
+      }
+    }
+
+    // Images cache also prepends its own prefix (usually 'assets/images/')
+    final imagesPrefix = images.prefix;
+    if (finalTexturePath.startsWith(imagesPrefix)) {
+      finalTexturePath = finalTexturePath.replaceFirst(imagesPrefix, '');
+    }
+
+    page.texture = await images.load(finalTexturePath, package: currentPackage);
   }
 
   _parsePageProperties(lineQueue, page);
@@ -436,7 +504,29 @@ void _parsePageProperties(ListQueue<String> lineQueue, Page page) {
 ///
 /// Returns the parsed [Region].
 Region _parseRegion(ListQueue<String> lineQueue, Page page) {
-  final name = lineQueue.removeFirst().trim();
+  var name = lineQueue.removeFirst().trim();
+  var extractedIndex = -1;
+
+  // Attempt to extract index and clean name if it follows patterns like
+  // 'name_01.png' or 'name_01'
+  final extensionMatch = RegExp(
+    r'\.(png|jpg|jpeg|bmp|tga|webp)$',
+    caseSensitive: false,
+  ).firstMatch(name);
+  if (extensionMatch != null) {
+    name = name.substring(0, extensionMatch.start);
+  }
+
+  final indexMatch = RegExp(r'_(\d+)$').firstMatch(name);
+  if (indexMatch != null) {
+    try {
+      extractedIndex = int.parse(indexMatch.group(1)!);
+      name = name.substring(0, indexMatch.start);
+    } catch (_) {
+      // Ignore parsing errors for very large numbers
+    }
+  }
+
   final values = <String, List<String>>{};
 
   while (lineQueue.isNotEmpty) {
@@ -504,7 +594,7 @@ Region _parseRegion(ListQueue<String> lineQueue, Page page) {
     originalHeight: finalOriginalHeight,
     degrees: _parseDegrees(rotate?.first),
     rotate: _parseDegrees(rotate?.first) == 90,
-    index: index != null ? int.parse(index[0]) : -1,
+    index: index != null ? int.parse(index[0]) : extractedIndex,
   );
 }
 

packages/flame_texturepacker/pubspec.yaml

@@ -18,7 +18,7 @@ environment:
 dependencies:
   collection: ^1.17.1
   cross_file: ^0.3.4+2
-  flame: ^1.36.0
+  flame: ^1.35.0
   flutter:
     sdk: flutter
 

packages/flame_texturepacker/test/atlas_path_resolution_test.dart

@@ -44,6 +44,8 @@ sprite1
       when(
         () => images.load(any(), package: any(named: 'package')),
       ).thenAnswer((_) async => FakeImage());
+
+      when(() => images.prefix).thenReturn('assets/images/');
     });
 
     test('should resolve paths correctly with leading slashes', () async {
@@ -124,5 +126,64 @@ sprite1
         () => images.load('images/test.png', package: 'my_package'),
       ).called(1);
     });
+
+    test(
+      'should auto-detect package from path if package parameter is null',
+      () async {
+        final assets = AssetsCache(bundle: bundle);
+
+        await TexturePackerAtlas.load(
+          'packages/custom_package/assets/images/atlas_name.atlas',
+          assets: assets,
+          images: images,
+        );
+
+        // Verify bundle call extracted 'custom_package' and cleaned the path
+        verify(
+          () => bundle.loadString(
+            'packages/custom_package/assets/images/atlas_name.atlas',
+            cache: any(named: 'cache'),
+          ),
+        ).called(1);
+
+        // Verify images.load also uses the extracted package
+        verify(
+          () => images.load('test.png', package: 'custom_package'),
+        ).called(1);
+      },
+    );
+
+    test(
+      'should correctly parse region names with .png and extracted indexes',
+      () async {
+        final assets = AssetsCache(bundle: bundle);
+        final complexAtlasContent = '''
+knight.png
+size: 64, 64
+filter: Nearest, Nearest
+repeat: none
+knight_walk_01.png
+  bounds: 0, 0, 32, 32
+knight_walk_02.png
+  bounds: 32, 0, 32, 32
+''';
+
+        when(
+          () => bundle.loadString(any(), cache: any(named: 'cache')),
+        ).thenAnswer((_) async => complexAtlasContent);
+
+        final atlas = await TexturePackerAtlas.load(
+          'knight.atlas',
+          assets: assets,
+          images: images,
+        );
+
+        expect(atlas.sprites.length, 2);
+        expect(atlas.sprites[0].region.name, 'knight_walk');
+        expect(atlas.sprites[0].region.index, 1);
+        expect(atlas.sprites[1].region.name, 'knight_walk');
+        expect(atlas.sprites[1].region.index, 2);
+      },
+    );
   });
 }