tilemap-editor 4.1.0__tar.gz → 4.2.0__tar.gz

{tilemap_editor-4.1.0/src/tilemap_editor.egg-info → tilemap_editor-4.2.0}/PKG-INFO

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

{tilemap_editor-4.1.0 → tilemap_editor-4.2.0}/pyproject.toml

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

{tilemap_editor-4.1.0 → tilemap_editor-4.2.0}/src/layers.py

@@ -4,7 +4,7 @@ Supports multiple layers with independent tile and object data.
 """
 
 import random
-from typing import TYPE_CHECKING, Dict, List, Optional, Tuple, Any
+from typing import TYPE_CHECKING, Dict, List, Optional, Set, Tuple, Any
 from ttypes.tilemap import TypeTile, TypeObject
 
 if TYPE_CHECKING:
@@ -83,6 +83,13 @@ class Layer:
     ) -> int:
         """
         Internal helper to update specific tiles according to autotile rules.
+
+        Group membership is determined by:
+        1. The tile's ``autotile_group`` field (if present)
+        2. Legacy fallback: (tileset_index, variant_id) lookup in variant_to_group
+
+        When a rule matches, the tile's variant is re-rolled from the rule's
+        variant_ids (removing the early-out that prevented re-autotile).
         """
         if self.locked or self.layer_type != "tile":
             return 0
@@ -98,9 +105,9 @@ class Layer:
         )
 
         if self._autotile_cache["rules_hash"] != rules_hash:
-            variant_to_group = {}
+            variant_to_group: Dict[Tuple[int, int], str] = {}
             rules_by_group: Dict[str, List["AutotileRule"]] = {}
-            significant_offsets = set()
+            significant_offsets: Set[Tuple[int, int]] = set()
 
             for rule in rules:
                 gid = rule.group_id
@@ -132,6 +139,13 @@ class Layer:
 
         changes_count = 0
 
+        def _get_group(t: dict) -> Optional[str]:
+            """Get group_id for a tile: autotile_group field > legacy variant lookup."""
+            ag = t.get("autotile_group")
+            if ag is not None:
+                return ag
+            return variant_to_group.get((t["ttype"], t["variant"]))
+
         for pos in positions:
             if pos not in self.tiles:
                 continue
@@ -140,10 +154,14 @@ class Layer:
             ttype = tile["ttype"]
             current_variant = tile["variant"]
 
-            target_group_id = variant_to_group.get((ttype, current_variant))
+            target_group_id = _get_group(tile)
             if not target_group_id:
                 continue
 
+            group_rules = rules_by_group.get(target_group_id)
+            if not group_rules:
+                continue
+
             actual_neighbors = []
             for dx, dy in [
                 (-1, -1),
@@ -158,8 +176,7 @@ class Layer:
                 npos = (pos[0] + dx, pos[1] + dy)
                 if npos in self.tiles:
                     n_tile = self.tiles[npos]
-                    n_group = variant_to_group.get((n_tile["ttype"], n_tile["variant"]))
-
+                    n_group = _get_group(n_tile)
                     if n_group == target_group_id:
                         actual_neighbors.append((dx, dy))
 
@@ -168,8 +185,6 @@ class Layer:
             }
 
             matched_rule: Optional["AutotileRule"] = None
-            group_rules = rules_by_group.get(target_group_id, [])
-
             for rule in group_rules:
                 if (
                     rule.neighbors == neighbor_offsets_set
@@ -179,12 +194,14 @@ class Layer:
                     break
 
             if matched_rule and matched_rule.variant_ids:
-                if current_variant in matched_rule.variant_ids:
-                    continue
-
                 new_variant = random.choice(matched_rule.variant_ids)
-                tile["variant"] = new_variant
-                changes_count += 1
+
+                if new_variant != current_variant:
+                    tile["variant"] = new_variant
+                    changes_count += 1
+
+                if "autotile_group" not in tile:
+                    tile["autotile_group"] = matched_rule.group_id
 
         return changes_count
 

{tilemap_editor-4.1.0 → tilemap_editor-4.2.0}/src/tilemap.py

@@ -1,7 +1,7 @@
 from json import dump as JSONDump
 from json import load as JSONLoad
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
 
 from pygame import Rect
 
@@ -271,11 +271,22 @@ class Tilemap:
             },
         }
 
+        ttype_to_firstgid: List[int] = []
         if hasattr(self.editor, "tileset_widget") and self.editor.tileset_widget:
+            firstgid = 0
+            tile_w, tile_h = self.tile_size
             for ts in self.editor.tileset_widget.tilesets:
                 path_str = to_project_path(ts.path, map_dir)
 
-                ts_data: Dict[str, Any] = {"path": path_str, "type": ts.tileset_type}
+                ts_surf = ts.surface
+                tile_count = (ts_surf.get_width() // tile_w) * (ts_surf.get_height() // tile_h)
+
+                ttype_to_firstgid.append(firstgid)
+
+                ts_data: Dict[str, Any] = {
+                    "path": path_str, "type": ts.tileset_type,
+                    "tile_count": tile_count, "firstgid": firstgid,
+                }
                 if ts.properties:
                     ts_data["properties"] = ts.properties
                 if ts.tile_properties:
@@ -284,6 +295,7 @@ class Tilemap:
                     ts_data["animation"] = ts.animation
 
                 save_data["resources"]["tilesets"].append(ts_data)
+                firstgid += tile_count
 
         if hasattr(self.editor, "autotiler") and self.editor.autotiler:
             if "groups" not in save_data["project_state"]:
@@ -324,11 +336,17 @@ class Tilemap:
 
             for loc, tile in layer.tiles.items():
                 key = serialize_point(loc)
+                ttype = tile["ttype"]
+                variant = tile["variant"]
                 tile_data: Dict[str, Any] = {
                     "pos": serialize_point(tile["pos"]),
-                    "ttype": tile["ttype"],
-                    "variant": tile["variant"],
+                    "ttype": ttype,
+                    "variant": variant,
                 }
+                if "autotile_group" in tile:
+                    tile_data["autotile_group"] = tile["autotile_group"]
+                if ttype_to_firstgid:
+                    tile_data["gid"] = ttype_to_firstgid[ttype] + variant
                 if "properties" in tile:
                     tile_data["properties"] = tile["properties"]
                 layer_data["tiles"][key] = tile_data
@@ -355,11 +373,17 @@ class Tilemap:
         if first_layer:
             for loc, tile in first_layer.tiles.items():
                 key = serialize_point(loc)
+                ttype = tile["ttype"]
+                variant = tile["variant"]
                 tile_data: Dict[str, Any] = {
                     "pos": serialize_point(tile["pos"]),
-                    "ttype": tile["ttype"],
-                    "variant": tile["variant"],
+                    "ttype": ttype,
+                    "variant": variant,
                 }
+                if "autotile_group" in tile:
+                    tile_data["autotile_group"] = tile["autotile_group"]
+                if ttype_to_firstgid:
+                    tile_data["gid"] = ttype_to_firstgid[ttype] + variant
                 save_data["data"]["ongrid"][key] = tile_data
 
         with open(target_path, "w") as f:
@@ -659,6 +683,8 @@ class Tilemap:
             tile_copy["pos"] = pos
             if "properties" in tile_data:
                 tile_copy["properties"] = tile_data["properties"]
+            if "autotile_group" in tile_data:
+                tile_copy["autotile_group"] = tile_data["autotile_group"]
             self._normalize_ttype(tile_copy)
             layer.tiles[pos] = tile_copy
 

{tilemap_editor-4.1.0 → tilemap_editor-4.2.0/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-4.1.0 → tilemap_editor-4.2.0}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -202,6 +202,8 @@ 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_gid_collision.py
+tests/test_layers_autotile.py
 tests/test_project_paths.py
 tests/test_render_scale.py
 tests/test_serialization_regression.py

{tilemap_editor-4.1.0 → tilemap_editor-4.2.0}/src/ttypes/tilemap.py

@@ -5,6 +5,8 @@ class TypeTile(TypedDict, total=True):
     pos: Tuple[int, int]
     ttype: int
     variant: int
+    autotile_group: NotRequired[str]
+    gid: NotRequired[int]
     properties: NotRequired[Dict[str, Any]]
 
 
@@ -35,6 +37,8 @@ class TypeTileSerealized(TypedDict, total=True):
     pos: str
     ttype: str
     variant: int
+    autotile_group: NotRequired[str]
+    gid: NotRequired[int]
     properties: NotRequired[Dict[str, Any]]
 
 
@@ -62,6 +66,8 @@ class TypeLayerSerialized(TypedDict, total=True):
 class TypeTilesetSerialized(TypedDict, total=True):
     path: str
     type: str
+    tile_count: NotRequired[int]
+    firstgid: NotRequired[int]
     properties: NotRequired[Dict[str, Any]]
     tile_properties: NotRequired[Dict[str, Dict[str, Any]]]
     animation: NotRequired[dict]

{tilemap_editor-4.1.0 → tilemap_editor-4.2.0}/src/widgets/tile_grid.py

@@ -659,6 +659,15 @@ class TileGrid:
                             variant_id
                         ].copy()
 
+                    if self.editor.autotile_mode and getattr(
+                        self.editor, "autotiler", None
+                    ):
+                        autotiler = self.editor.autotiler
+                        if autotiler.groups:
+                            gidx = autotiler.selected_group_idx
+                            if 0 <= gidx < len(autotiler.groups):
+                                tile_data["autotile_group"] = autotiler.groups[gidx].name
+
                     active_layer.set_tile(target_pos, tile_data)
 
                     if self.editor.autotile_mode and getattr(

tilemap_editor-4.2.0/tests/test_gid_collision.py

@@ -0,0 +1,43 @@
+"""Tests for GID-based collision resolution (no firstgid in collision library)."""
+
+from plugins.tileset_collision.models import (
+    TilesetCollisionLibrary,
+    TileCollisionData,
+    CollisionPolygon,
+)
+
+
+class TestTilesetCollisionLibraryNoFirstgid:
+    def test_to_dict_no_firstgid(self):
+        lib = TilesetCollisionLibrary(
+            tileset_name="test", tile_size=(32, 32),
+            tiles={5: TileCollisionData(tile_id=5, shapes=[
+                CollisionPolygon(vertices=[(0, 0), (32, 0), (32, 32), (0, 32)]),
+            ])},
+        )
+        d = lib.to_dict()
+        assert "firstgid" not in d
+        assert d["tileset_name"] == "test"
+        assert "5" in d["tiles"]
+
+    def test_roundtrip_ignores_firstgid(self):
+        d = {
+            "tileset_name": "test",
+            "tile_size": [16, 16],
+            "firstgid": 100,
+            "tiles": {"0": {"tile_id": 0, "shapes": []}},
+        }
+        lib = TilesetCollisionLibrary.from_dict(d)
+        assert not hasattr(lib, "firstgid")
+        assert 0 in lib.tiles
+
+    def test_keeps_existing_fields(self):
+        lib = TilesetCollisionLibrary(
+            tileset_name="test", tile_size=(32, 32),
+            tiles={0: TileCollisionData(tile_id=0)},
+        )
+        d = lib.to_dict()
+        restored = TilesetCollisionLibrary.from_dict(d)
+        assert restored.tileset_name == "test"
+        assert restored.tile_size == (32, 32)
+        assert 0 in restored.tiles