tilemap-editor 3.2.2__tar.gz → 3.2.4__tar.gz

{tilemap_editor-3.2.2/src/tilemap_editor.egg-info → tilemap_editor-3.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 3.2.2
+Version: 3.2.4
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.2.2"
+version = "3.2.4"
 description = "Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools"
 readme = "README.md"
 requires-python = ">=3.10"

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4}/src/editor.py

@@ -150,6 +150,9 @@ class Editor:
         self.running = False
         self.pan_mode = False
         self.autotile_mode = False
+        self.eraser_mode = False
+        self.select_mode = False
+        self._prev_tool = None
 
         if isinstance(size, tuple) and len(size) == 2:
             self.screen = pygame.display.set_mode(size, pygame.RESIZABLE)
@@ -684,13 +687,17 @@ class Editor:
         self.open_file_manager(
             on_select=self._launch_animation_editor_with_image,
             initial_dir=self.data_root,
-            allowed_exts=[".png", ".jpg", ".jpeg"],
+            allowed_exts=[".png", ".jpg", ".jpeg", ".json"],
             mode="open",
         )
 
     def _launch_animation_editor_with_image(self, path: Path):
-        """Launch animation editor subprocess with selected image."""
+        """Launch animation editor subprocess with selected image or JSON."""
         try:
+            if path.suffix.lower() == ".json":
+                self._launch_animation_editor_with_json(path)
+                return
+
             tile_size = "32x32"
             if hasattr(self.tilemap, "tile_size") and self.tilemap.tile_size:
                 tw, th = self.tilemap.tile_size
@@ -711,6 +718,47 @@ class Editor:
         except Exception as e:
             error_handler.capture(e, context="launch_animation_editor")
 
+    def _launch_animation_editor_with_json(self, path: Path) -> None:
+        """Launch animation editor from a saved .anim.json file."""
+        try:
+            from plugins.sprite_animation.models import AnimationLibrary
+            from utils.project_paths import resolve_project_path
+
+            lib = AnimationLibrary.load(path)
+            spritesheet_path = lib.spritesheet_path
+            tile_size = lib.tile_size
+
+            if spritesheet_path:
+                resolved = resolve_project_path(
+                    spritesheet_path,
+                    path.parent,
+                    fallback_roots=[self.base_path] if self.base_path else None,
+                    must_exist=True,
+                )
+            else:
+                resolved = None
+
+            if not resolved or not resolved.exists():
+                print(f"Could not locate spritesheet for animation file: {path.name}")
+                return
+
+            args = [
+                str(resolved),
+                "--tile-size", f"{tile_size[0]}x{tile_size[1]}",
+                "--load", str(path),
+                "--data-root", str(self.data_root),
+            ]
+            process = launch_standalone(
+                "plugins.sprite_animation.standalone",
+                args,
+                cwd=self.base_path,
+                text=True,
+            )
+            self.child_processes.append(process)
+            print(f"Launched animation editor with: {path.name} (spritesheet: {resolved.name})")
+        except Exception as e:
+            error_handler.capture(e, context="launch_animation_editor")
+
     def launch_sprite_editor(self):
         """Launch the sprite editor in a new window."""
         self.open_file_manager(
@@ -775,6 +823,11 @@ class Editor:
 
         args = [str(path), "--tile-size", tile_size, "--data-root", str(self.data_root)]
 
+        # Collect auto-tile variant groups for this tileset and pass as --propagation-groups
+        propagation_groups_path = self._write_propagation_groups(path)
+        if propagation_groups_path:
+            args.extend(["--propagation-groups", str(propagation_groups_path)])
+
         collision_dir = self.data_root / self.config.get("collision_paths", {}).get("tileset", "collision")
         collision_path = collision_dir / f"{path.stem}.collision.json"
         if collision_path.exists():
@@ -793,6 +846,54 @@ class Editor:
         if logger:
             logger.info(msg)
 
+    def _write_propagation_groups(self, tileset_path: Path) -> Optional[Path]:
+        """Collect auto-tile variant groups for a tileset and write to temp JSON.
+
+        Returns the path to the temp file, or None if no autotiler data is available.
+        """
+        if not hasattr(self, "autotiler") or not self.autotiler:
+            return None
+
+        tw = getattr(self, "tileset_widget", None)
+        if not tw or not tw.tilesets:
+            return None
+
+        # Find the tileset index matching the given path
+        resolved_path = Path(tileset_path).resolve()
+        tileset_index = None
+        for idx, ts in enumerate(tw.tilesets):
+            try:
+                if Path(ts.path).resolve() == resolved_path:
+                    tileset_index = idx
+                    break
+            except (OSError, ValueError):
+                continue
+
+        if tileset_index is None:
+            return None
+
+        # Collect variant_ids grouped by group_id from autotile rules matching this tileset
+        groups: Dict[str, List[int]] = {}
+        for group in self.autotiler.groups:
+            for rule in group.rules:
+                if rule.tileset_index == tileset_index and rule.variant_ids:
+                    gid = rule.group_id or group.name
+                    if gid not in groups:
+                        groups[gid] = []
+                    groups[gid].extend(rule.variant_ids)
+
+        if not groups:
+            return None
+
+        import json
+        import tempfile
+        fd, tmp_path = tempfile.mkstemp(suffix=".json", prefix="propagation_groups_")
+        with os.fdopen(fd, "w") as f:
+            json.dump(groups, f)
+
+        print(f"[COLLISION] Wrote {len(groups)} propagation groups to {tmp_path}")
+        return Path(tmp_path)
+
     def _launch_object_tileset_collision_editor_with_image(self, path: Path):
         """Launch object tileset collision editor (region-based)."""
         logger = self.logger if hasattr(self, 'logger') else None
@@ -1018,7 +1119,24 @@ class Editor:
                     self.perform_load()
                     continue
                 elif event.key == pygame.K_SPACE:
-                    self.pan_mode = not self.pan_mode
+                    if self.pan_mode:
+                        # Restoring: turn off pan, re-enable previous tool
+                        self.pan_mode = False
+                        if getattr(self, "_prev_tool", None) == "select":
+                            self.select_mode = True
+                        elif getattr(self, "_prev_tool", None) == "eraser":
+                            self.eraser_mode = True
+                    else:
+                        # Entering pan: save current tool, turn off others
+                        if self.select_mode:
+                            self._prev_tool = "select"
+                        elif self.eraser_mode:
+                            self._prev_tool = "eraser"
+                        else:
+                            self._prev_tool = None
+                        self.pan_mode = True
+                        self.select_mode = False
+                        self.eraser_mode = False
                     continue
                 elif event.mod & pygame.KMOD_CTRL and event.key == pygame.K_g:
                     self.toggle_grid()

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4}/src/plugins/sprite_animation/editor.py

@@ -1367,7 +1367,7 @@ class SpriteAnimationEditor:
             self.preview.set_surface(self._surface, self._tile_size)
             self.timeline.surface = self._surface
             self.timeline.tile_size = self._tile_size
-            self.timeline._thumb_cache.clear()
+            self.timeline.invalidate_cache()
 
             # Update input fields to show clamped values
             self._frame_width_input = str(width)
@@ -1404,7 +1404,7 @@ class SpriteAnimationEditor:
             if hasattr(self.timeline, "grid_offset_x"):
                 self.timeline.grid_offset_x = offset_x
                 self.timeline.grid_offset_y = offset_y
-                self.timeline._thumb_cache.clear()
+                self.timeline.invalidate_cache()
 
             # Update preview with offset (if it has the attribute)
             if hasattr(self.preview, "grid_offset_x"):
@@ -1420,6 +1420,43 @@ class SpriteAnimationEditor:
             self._offset_x_input = str(self._grid_offset_x)
             self._offset_y_input = str(self._grid_offset_y)
 
+    def _apply_library_grid_settings(self) -> None:
+        """Sync tile_size and grid_offset from the loaded library to all widgets."""
+        tw, th = self.library.tile_size
+        self._tile_size = (tw, th)
+        self.library.tile_size = (tw, th)
+
+        # Update frame picker
+        self.frame_picker.set_surface(self._surface, self._tile_size)
+
+        # Update preview and timeline
+        self.preview.set_surface(self._surface, self._tile_size)
+        self.timeline.surface = self._surface
+        self.timeline.tile_size = self._tile_size
+        self.timeline.invalidate_cache()
+
+        # Update frame size input fields
+        self._frame_width_input = str(tw)
+        self._frame_height_input = str(th)
+
+        # Sync grid offset from library
+        gx, gy = self.library.grid_offset
+        self._grid_offset_x = gx
+        self._grid_offset_y = gy
+        self._offset_x_input = str(gx)
+        self._offset_y_input = str(gy)
+
+        # Propagate offset to all widgets
+        if hasattr(self.frame_picker, "set_grid_offset"):
+            self.frame_picker.set_grid_offset(gx, gy)
+        if hasattr(self.timeline, "grid_offset_x"):
+            self.timeline.grid_offset_x = gx
+            self.timeline.grid_offset_y = gy
+            self.timeline.invalidate_cache()
+        if hasattr(self.preview, "grid_offset_x"):
+            self.preview.grid_offset_x = gx
+            self.preview.grid_offset_y = gy
+
     def _sync_active_animation(self) -> None:
         """Push current animation data to sub-widgets."""
         anim = self._get_active()
@@ -1843,6 +1880,7 @@ class SpriteAnimationEditor:
             print(f"Warning: Could not import FileManager: {e}")
             path = self._default_save_path()
             try:
+                self.library.grid_offset = (self._grid_offset_x, self._grid_offset_y)
                 self.library.save(path, base_path=path.parent)
                 self._last_saved_path = path
                 print(f"Animations saved to {path}")
@@ -1888,6 +1926,7 @@ class SpriteAnimationEditor:
         if self._last_saved_path:
             # Save to existing path
             try:
+                self.library.grid_offset = (self._grid_offset_x, self._grid_offset_y)
                 self.library.save(
                     self._last_saved_path,
                     base_path=self._last_saved_path.parent,
@@ -1913,6 +1952,7 @@ class SpriteAnimationEditor:
                 try:
                     self.library = AnimationLibrary.load(path)
                     self._resolve_library_paths(path)
+                    self._apply_library_grid_settings()
                     names = self.library.animation_names()
                     self._active_anim_name = names[0] if names else None
                     if not names:
@@ -1948,6 +1988,8 @@ class SpriteAnimationEditor:
     def _on_save_file_selected(self, path: Path) -> None:
         """Callback when user selects a file to save to."""
         try:
+            # Sync current grid offset into library before saving
+            self.library.grid_offset = (self._grid_offset_x, self._grid_offset_y)
             self.library.save(path, base_path=path.parent)
             self._last_saved_path = path  # Track for quick save
             print(f"Animations saved to {path}")
@@ -1968,6 +2010,7 @@ class SpriteAnimationEditor:
                 self.library = AnimationLibrary.load(path)
                 self._resolve_library_paths(path)
                 self._last_saved_path = path  # Track loaded file as save location
+                self._apply_library_grid_settings()
                 names = self.library.animation_names()
                 self._active_anim_name = names[0] if names else None
                 if not names:
@@ -2110,6 +2153,7 @@ class SpriteAnimationEditor:
     def load_animation_data(self, data: dict) -> None:
         """Load animation library from a dict (e.g. from project JSON)."""
         self.library = AnimationLibrary.from_dict(data)
+        self._apply_library_grid_settings()
         names = self.library.animation_names()
         self._active_anim_name = names[0] if names else None
         if not names:

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4}/src/plugins/sprite_animation/models.py

@@ -167,6 +167,7 @@ class AnimationLibrary:
     animations: Dict[str, Animation] = field(default_factory=dict)
     spritesheet_path: Optional[str] = None
     tile_size: Tuple[int, int] = (32, 32)
+    grid_offset: Tuple[int, int] = (0, 0)
 
     def add_animation(self, anim: Animation) -> None:
         self.animations[anim.name] = anim
@@ -199,6 +200,7 @@ class AnimationLibrary:
         return {
             "spritesheet_path": spritesheet_path,
             "tile_size": list(self.tile_size),
+            "grid_offset": list(self.grid_offset),
             "animations": {
                 name: anim.to_dict() for name, anim in self.animations.items()
             },
@@ -209,6 +211,7 @@ class AnimationLibrary:
         lib = AnimationLibrary(
             spritesheet_path=data.get("spritesheet_path"),
             tile_size=tuple(data.get("tile_size", [32, 32])),
+            grid_offset=tuple(data.get("grid_offset", [0, 0])),
         )
         for name, anim_data in data.get("animations", {}).items():
             lib.animations[name] = Animation.from_dict(anim_data)

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4}/src/plugins/sprite_animation/timeline.py

@@ -140,6 +140,10 @@ class Timeline:
             self.tile_size = tile_size
         self._thumb_cache.clear()
 
+    def invalidate_cache(self) -> None:
+        """Clear the thumbnail cache. Call after external changes to surface, tile_size, or grid offset."""
+        self._thumb_cache.clear()
+
     def resize(self, rect: Rect) -> None:
         self.rect = rect
 

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4}/src/plugins/tileset_collision/editor.py

@@ -72,6 +72,9 @@ class TilesetCollisionEditor:
         self._toast_timer: float = 0.0
         self._toast_start: int = 0
 
+        # Auto-tile propagation: group_id -> [variant_ids]
+        self._propagation_groups: Dict[str, List[int]] = {}
+
         # Collision library
         self.library = TilesetCollisionLibrary(
             tileset_name=self._tileset_name,
@@ -436,13 +439,53 @@ class TilesetCollisionEditor:
             error_handler.capture(e, context="load_collision_data")
 
     def save_to_file(self, path: Path) -> None:
-        """Save collision data to file"""
+        """Save collision data to file, auto-propagating within auto-tile groups."""
         try:
             self._save_tile_collision_for_selection()
+            self._propagate_collision_to_groups()
             self.library.save(path)
         except Exception as e:
             error_handler.capture(e, context="save_collision_file")
 
+    def _propagate_collision_to_groups(self) -> None:
+        """Propagate collision shapes within each auto-tile group.
+
+        If any tile in a propagation group has collision shapes, those shapes
+        are copied to all other tiles in the same group that don't already
+        have their own collision data.
+        """
+        if not self._propagation_groups:
+            return
+
+        propagated_count = 0
+        for group_id, variant_ids in self._propagation_groups.items():
+            # Find the first tile in this group that has collision shapes
+            source_shapes = None
+            for vid in variant_ids:
+                tile_data = self.library.tiles.get(vid)
+                if tile_data and tile_data.shapes:
+                    source_shapes = tile_data.shapes
+                    break
+
+            if source_shapes is None:
+                continue
+
+            # Propagate to all variants in the group that lack collision
+            for vid in variant_ids:
+                existing = self.library.tiles.get(vid)
+                if existing is None:
+                    self.library.tiles[vid] = TileCollisionData(
+                        tile_id=vid,
+                        shapes=[CollisionPolygon(
+                            vertices=list(s.vertices),
+                            one_way=s.one_way,
+                        ) for s in source_shapes],
+                    )
+                    propagated_count += 1
+
+        if propagated_count:
+            self._show_toast(f"Propagated collision to {propagated_count} auto-tile variants")
+
     def load_from_file(self, path: Path) -> None:
         """Load collision data from file"""
         try:
@@ -829,6 +872,7 @@ class TilesetCollisionEditor:
         tile_size: Tuple[int, int] = (32, 32),
         window_size: Tuple[int, int] = (1200, 800),
         data_root: Path = None,
+        propagation_groups: Optional[Dict[str, List[int]]] = None,
     ) -> "TilesetCollisionEditor":
         """Create editor from tileset image path (for standalone use)"""
         surface = pygame.image.load(tileset_path).convert_alpha()
@@ -838,6 +882,7 @@ class TilesetCollisionEditor:
         editor._tileset_path_stem = tileset_path.stem
         editor._tileset_name = tileset_path.stem  # Use actual filename, not "Tileset"
         editor.library.tileset_name = tileset_path.stem
+        editor._propagation_groups = propagation_groups or {}
         return editor
 
     def run(self) -> None:

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4}/src/plugins/tileset_collision/standalone.py

@@ -86,6 +86,12 @@ def main(argv: list[str] | None = None) -> None:
             required=True,
             help="Path to project data root directory (REQUIRED)",
         )
+        parser.add_argument(
+            "--propagation-groups",
+            type=Path,
+            default=None,
+            help="Path to JSON file mapping auto-tile group IDs to variant ID lists",
+        )
 
         args = parser.parse_args(argv)
 
@@ -107,11 +113,23 @@ def main(argv: list[str] | None = None) -> None:
             screen = pygame.display.set_mode(window_size, pygame.RESIZABLE)
             pygame.display.set_caption(f"Tileset Collision Editor — {args.image.name}")
 
+            propagation_groups = None
+            if args.propagation_groups and args.propagation_groups.exists():
+                import json
+                with open(args.propagation_groups) as f:
+                    propagation_groups = json.load(f)
+                print(f"Loaded {len(propagation_groups)} auto-tile propagation groups")
+                try:
+                    args.propagation_groups.unlink()
+                except OSError:
+                    pass
+
             editor = TilesetCollisionEditor.from_path(
                 args.image,
                 tile_size=tile_size,
                 window_size=window_size,
                 data_root=data_root,
+                propagation_groups=propagation_groups,
             )
 
             if args.load and args.load.exists():

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4/src/tilemap_editor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 3.2.2
+Version: 3.2.4
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-3.2.2 → tilemap_editor-3.2.4}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -177,8 +177,15 @@ src/widgets/ui/theme.py
 src/widgets/ui/tileset_type_dialog.py
 src/widgets/ui/toolbar.py
 src/widgets/ui/tooltip.py
+tests/test_animation_library_grid_offset.py
 tests/test_collision_layer_mask.py
 tests/test_collision_layer_sidebar.py
+tests/test_editor_pan_mode.py
 tests/test_project_paths.py
 tests/test_render_scale.py
-tests/test_tilemap_save.py
+tests/test_sprite_animation_editor_grid.py
+tests/test_tile_grid_selection.py
+tests/test_tile_selector_pick.py
+tests/test_tilemap_save.py
+tests/test_timeline_invalidate_cache.py
+tests/test_toolbar_tools.py