tilemap-editor 4.3.2__tar.gz → 4.3.4__tar.gz

{tilemap_editor-4.3.2/src/tilemap_editor.egg-info → tilemap_editor-4.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 4.3.2
+Version: 4.3.4
 Summary: Pygame tilemap editor with collision, animation, sprite & particle tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-4.3.2 → tilemap_editor-4.3.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "4.3.2"
+version = "4.3.4"
 description = "Pygame tilemap editor with collision, animation, sprite & particle tools"
 readme = "README.md"
 requires-python = ">=3.11"

{tilemap_editor-4.3.2 → tilemap_editor-4.3.4}/src/layers.py

@@ -27,6 +27,8 @@ class Layer:
         visible: bool = True,
         locked: bool = False,
         opacity: float = 1.0,
+        y_sort: bool = False,
+        y_sort_origin: int = 0,
     ):
         self.name = name
         self.layer_type = layer_type
@@ -34,6 +36,8 @@ class Layer:
         self.visible = visible
         self.locked = locked
         self.opacity = max(0.0, min(1.0, opacity))
+        self.y_sort = y_sort
+        self.y_sort_origin = y_sort_origin
         self.properties: dict[str, Any] = {}
 
         self.tiles: dict[tuple[int, int], TypeTile] = {}
@@ -303,6 +307,8 @@ class Layer:
             "visible": self.visible,
             "locked": self.locked,
             "opacity": self.opacity,
+            "y_sort": self.y_sort,
+            "y_sort_origin": self.y_sort_origin,
         }
 
         if self.tiles:
@@ -331,6 +337,8 @@ class Layer:
             visible=data.get("visible", True),
             locked=data.get("locked", False),
             opacity=data.get("opacity", 1.0),
+            y_sort=data.get("y_sort", False),
+            y_sort_origin=data.get("y_sort_origin", 0),
         )
 
         if "tiles" in data:

{tilemap_editor-4.3.2 → tilemap_editor-4.3.4}/src/tilemap.py

@@ -331,6 +331,8 @@ class Tilemap:
                 "locked": layer.locked,
                 "opacity": layer.opacity,
                 "z_index": layer.z_index,
+                "y_sort": layer.y_sort,
+                "y_sort_origin": layer.y_sort_origin,
                 "tiles": {},
             }
 
@@ -674,6 +676,8 @@ class Tilemap:
             visible=layer_data.get("visible", True),
             locked=layer_data.get("locked", False),
             opacity=layer_data.get("opacity", 1.0),
+            y_sort=layer_data.get("y_sort", False),
+            y_sort_origin=layer_data.get("y_sort_origin", 0),
         )
         layer.properties = layer_data.get("properties", {})
 

{tilemap_editor-4.3.2 → tilemap_editor-4.3.4/src/tilemap_editor.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 4.3.2
+Version: 4.3.4
 Summary: Pygame tilemap editor with collision, animation, sprite & particle tools
 Author: tilemap editor contributors
 License: Proprietary

{tilemap_editor-4.3.2 → tilemap_editor-4.3.4}/src/widgets/layer_selector.py

@@ -109,6 +109,15 @@ class LayerSelector:
                                 layer.locked = not layer.locked
                                 return True
 
+                        ysort_rect = self._get_ysort_icon_rect(layer_idx)
+                        if ysort_rect and ysort_rect.collidepoint(mouse_pos):
+                            layer = self.editor.tilemap.layer_manager.get_layer(
+                                layer_idx
+                            )
+                            if layer:
+                                layer.y_sort = not layer.y_sort
+                                return True
+
                         opacity_rect = self._get_opacity_bar_rect(layer_idx)
                         if opacity_rect and opacity_rect.collidepoint(mouse_pos):
                             layer = self.editor.tilemap.layer_manager.get_layer(
@@ -269,6 +278,27 @@ class LayerSelector:
         bar_y = item_y + self.item_h - bar_h - 3
         return Rect(bar_x, bar_y, bar_w, bar_h)
 
+    def _get_ysort_icon_rect(self, layer_idx: int) -> Rect | None:
+        """Get the clickable rect for the y-sort toggle of a layer."""
+        if layer_idx is None:
+            return None
+
+        item_y = self.list_rect.y + (layer_idx * self.item_h) - self.scroll_offset
+
+        if item_y + self.item_h < self.list_rect.y or item_y > self.list_rect.bottom:
+            return None
+
+        item_rect = Rect(
+            self.list_rect.x,
+            item_y,
+            self.list_rect.width,
+            self.item_h,
+        )
+
+        ysort_x = item_rect.x + 5
+        ysort_y = item_rect.y + 4
+        return Rect(ysort_x, ysort_y, 12, 20)
+
     def _get_eye_icon_rect(self, layer_idx: int, mouse_pos) -> Rect | None:
         """Get the clickable rect for the eye icon of a layer."""
         if layer_idx is None:
@@ -435,16 +465,20 @@ class LayerSelector:
             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))
+            ysort_rect = self._get_ysort_icon_rect(i)
             if eye_rect and eye_rect.collidepoint(mx, my):
                 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))
+            elif ysort_rect and ysort_rect.collidepoint(mx, my):
+                label = "On" if layer.y_sort else "Off"
+                self.editor.tooltip.show(f"Y-Sort: {label}", (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),
+                    Rect(item_rect.x + 22, item_rect.y + 4, 120, 20),
                     border_radius=SHAPE.radius_sm,
                 )
                 name_txt = self.font_layer.render(
@@ -452,7 +486,7 @@ class LayerSelector:
                 )
             else:
                 name_txt = self.font_layer.render(layer.name, True, COLORS.text)
-            screen.blit(name_txt, (item_rect.x + 5, item_rect.y + 5))
+            screen.blit(name_txt, (item_rect.x + 22, item_rect.y + 5))
 
             opacity_bar = self._get_opacity_bar_rect(i)
             if opacity_bar:
@@ -508,6 +542,16 @@ class LayerSelector:
                     screen, COLORS.text_muted, Rect(lock_x - 4, lock_y - 4, 8, 8), 1
                 )
 
+            ysort_rect = self._get_ysort_icon_rect(i)
+            if ysort_rect:
+                ysort_color = COLORS.accent if layer.y_sort else COLORS.text_dim
+                pygame.draw.rect(
+                    screen, ysort_color, ysort_rect, 
+                    border_radius=SHAPE.radius_sm,
+                )
+                ysort_txt = self.font_layer.render("Y", True, COLORS.text)
+                screen.blit(ysort_txt, (ysort_rect.x + 3, ysort_rect.y + 3))
+
         if self.dragging_layer_idx is not None:
             mouse_y = pygame.mouse.get_pos()[1]
             dragging_layer = layer_manager.layers[self.dragging_layer_idx]
@@ -525,7 +569,7 @@ class LayerSelector:
             screen.blit(drag_surf, preview_rect)
 
             name_txt = self.font_layer.render(dragging_layer.name, True, COLORS.text)
-            screen.blit(name_txt, (preview_rect.x + 5, preview_rect.y + 5))
+            screen.blit(name_txt, (preview_rect.x + 22, preview_rect.y + 5))
 
             pygame.draw.rect(screen, (150, 150, 255), preview_rect, 2)
 

{tilemap_editor-4.3.2 → tilemap_editor-4.3.4}/tests/test_layers_autotile.py

@@ -1018,3 +1018,48 @@ class TestPropagation:
         changes = layer._autotile_tiles([solo, top], [(5, 5)])
         assert changes == 1
         assert layer.tiles[(5, 5)]["variant"] == 1
+
+
+class TestLayerYSort:
+    def test_default_is_false(self):
+        layer = Layer("test")
+        assert layer.y_sort is False
+
+    def test_to_dict_includes_y_sort(self):
+        layer = Layer("test", layer_type="tile")
+        layer.y_sort = True
+        data = layer.to_dict()
+        assert data["y_sort"] is True
+
+    def test_from_dict_reads_y_sort(self):
+        layer = Layer.from_dict({"name": "test", "type": "tile", "y_sort": True})
+        assert layer.y_sort is True
+
+    def test_from_dict_defaults_false(self):
+        layer = Layer.from_dict({"name": "test", "type": "tile"})
+        assert layer.y_sort is False
+
+    def test_roundtrip(self):
+        layer = Layer("bushes", layer_type="tile", y_sort=True)
+        data = layer.to_dict()
+        restored = Layer.from_dict(data)
+        assert restored.y_sort is True
+        assert restored.name == "bushes"
+
+    def test_y_sort_origin_defaults_to_zero(self):
+        layer = Layer("test")
+        assert layer.y_sort_origin == 0
+
+    def test_to_dict_includes_y_sort_origin(self):
+        layer = Layer("test", y_sort_origin=16)
+        data = layer.to_dict()
+        assert data["y_sort_origin"] == 16
+
+    def test_from_dict_reads_y_sort_origin(self):
+        layer = Layer.from_dict({"name": "test", "type": "tile", "y_sort_origin": 32})
+        assert layer.y_sort_origin == 32
+
+    def test_y_sort_origin_roundtrip(self):
+        layer = Layer("test", y_sort=True, y_sort_origin=24)
+        restored = Layer.from_dict(layer.to_dict())
+        assert restored.y_sort_origin == 24