tilemap-editor 3.2.3__tar.gz → 3.2.5__tar.gz

{tilemap_editor-3.2.3/src/tilemap_editor.egg-info → tilemap_editor-3.2.5}/PKG-INFO

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

{tilemap_editor-3.2.3 → tilemap_editor-3.2.5}/pyproject.toml

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

{tilemap_editor-3.2.3 → tilemap_editor-3.2.5}/src/editor.py

@@ -823,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():
@@ -841,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

{tilemap_editor-3.2.3 → tilemap_editor-3.2.5}/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.3 → tilemap_editor-3.2.5}/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.3 → tilemap_editor-3.2.5/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.2.3 → tilemap_editor-3.2.5}/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

{tilemap_editor-3.2.3 → tilemap_editor-3.2.5}/src/widgets/layer_selector.py

@@ -382,13 +382,6 @@ class LayerSelector:
             pygame.draw.rect(screen, color, item_rect)
             pygame.draw.rect(screen, COLORS.border_soft, item_rect, 1)
 
-            if i == self.renaming_layer_idx:
-                pygame.draw.rect(
-                    screen,
-                    COLORS.selected,
-                    Rect(item_rect.x + 4, item_rect.y + 4, 120, 20),
-                    border_radius=SHAPE.radius_sm,
-                )
             mx, my = pygame.mouse.get_pos()
             eye_rect = self._get_eye_icon_rect(i, (mx, my))
             lock_rect = self._get_lock_icon_rect(i, (mx, my))
@@ -396,13 +389,20 @@ class LayerSelector:
                 self.editor.tooltip.show("Toggle Visibility", (mx + 10, my + 10))
             elif lock_rect and lock_rect.collidepoint(mx, my):
                 self.editor.tooltip.show("Toggle Lock", (mx + 10, my + 10))
+
+            if i == self.renaming_layer_idx:
+                pygame.draw.rect(
+                    screen,
+                    COLORS.selected,
+                    Rect(item_rect.x + 4, item_rect.y + 4, 120, 20),
+                    border_radius=SHAPE.radius_sm,
+                )
                 name_txt = self.font_layer.render(
                     self.rename_text + "|", True, self.text_color
                 )
-                screen.blit(name_txt, (item_rect.x + 5, item_rect.y + 5))
             else:
                 name_txt = self.font_layer.render(layer.name, True, self.text_color)
-                screen.blit(name_txt, (item_rect.x + 5, item_rect.y + 5))
+            screen.blit(name_txt, (item_rect.x + 5, item_rect.y + 5))
 
             eye_x = item_rect.right - 25
             eye_y = item_rect.y + 7

tilemap_editor-3.2.5/tests/test_animation_library_grid_offset.py

@@ -0,0 +1,150 @@
+"""
+Tests for AnimationLibrary.grid_offset field added in PR.
+
+Covers:
+- Default value
+- to_dict serializes grid_offset
+- from_dict deserializes grid_offset
+- from_dict falls back to (0, 0) when key is missing (backward compat)
+- save/load round-trip preserves grid_offset
+- grid_offset is a tuple (not list) after deserialization
+"""
+
+import json
+import tempfile
+from pathlib import Path
+
+import pytest
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+
+class TestAnimationLibraryGridOffset:
+    """Tests for the grid_offset field on AnimationLibrary."""
+
+    def test_default_grid_offset_is_zero(self):
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        lib = AnimationLibrary()
+        assert lib.grid_offset == (0, 0)
+
+    def test_to_dict_includes_grid_offset(self):
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        lib = AnimationLibrary(grid_offset=(4, 8))
+        d = lib.to_dict()
+        assert "grid_offset" in d
+        assert d["grid_offset"] == [4, 8]
+
+    def test_to_dict_zero_grid_offset(self):
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        lib = AnimationLibrary(grid_offset=(0, 0))
+        d = lib.to_dict()
+        assert d["grid_offset"] == [0, 0]
+
+    def test_from_dict_reads_grid_offset(self):
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        data = {
+            "spritesheet_path": None,
+            "tile_size": [32, 32],
+            "grid_offset": [10, 20],
+            "animations": {},
+        }
+        lib = AnimationLibrary.from_dict(data)
+        assert lib.grid_offset == (10, 20)
+
+    def test_from_dict_missing_grid_offset_defaults_to_zero(self):
+        """Backward-compat: old JSON files without grid_offset key should load fine."""
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        data = {
+            "spritesheet_path": None,
+            "tile_size": [32, 32],
+            "animations": {},
+        }
+        lib = AnimationLibrary.from_dict(data)
+        assert lib.grid_offset == (0, 0)
+
+    def test_from_dict_grid_offset_is_tuple(self):
+        """grid_offset should be a tuple after deserialization, not a list."""
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        data = {
+            "spritesheet_path": None,
+            "tile_size": [32, 32],
+            "grid_offset": [5, 3],
+            "animations": {},
+        }
+        lib = AnimationLibrary.from_dict(data)
+        assert isinstance(lib.grid_offset, tuple)
+
+    def test_save_load_round_trip_preserves_grid_offset(self):
+        """save() then load() must preserve a non-zero grid_offset."""
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        lib = AnimationLibrary(grid_offset=(7, 13), tile_size=(16, 16))
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "anim.json"
+            lib.save(path)
+            loaded = AnimationLibrary.load(path)
+
+        assert loaded.grid_offset == (7, 13)
+
+    def test_save_load_round_trip_zero_grid_offset(self):
+        """save() then load() preserves (0, 0) grid_offset."""
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        lib = AnimationLibrary(grid_offset=(0, 0))
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "anim.json"
+            lib.save(path)
+            loaded = AnimationLibrary.load(path)
+
+        assert loaded.grid_offset == (0, 0)
+
+    def test_to_dict_grid_offset_is_list(self):
+        """grid_offset is serialized as a JSON list (not tuple) for JSON compat."""
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        lib = AnimationLibrary(grid_offset=(2, 6))
+        d = lib.to_dict()
+        assert isinstance(d["grid_offset"], list)
+
+    def test_grid_offset_stored_alongside_tile_size(self):
+        """Both tile_size and grid_offset appear in the serialized dict."""
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        lib = AnimationLibrary(tile_size=(16, 16), grid_offset=(4, 4))
+        d = lib.to_dict()
+        assert d["tile_size"] == [16, 16]
+        assert d["grid_offset"] == [4, 4]
+
+    def test_from_dict_large_grid_offset(self):
+        """Arbitrary large values are preserved."""
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        data = {
+            "spritesheet_path": None,
+            "tile_size": [32, 32],
+            "grid_offset": [128, 256],
+            "animations": {},
+        }
+        lib = AnimationLibrary.from_dict(data)
+        assert lib.grid_offset == (128, 256)
+
+    def test_json_file_contains_grid_offset_key(self):
+        """The written JSON file contains the grid_offset key."""
+        from plugins.sprite_animation.models import AnimationLibrary
+
+        lib = AnimationLibrary(grid_offset=(3, 9))
+        with tempfile.TemporaryDirectory() as tmp:
+            path = Path(tmp) / "anim.json"
+            lib.save(path)
+            with open(path) as f:
+                raw = json.load(f)
+
+        assert "grid_offset" in raw
+        assert raw["grid_offset"] == [3, 9]