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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 4.3.4
+Version: 4.3.6
 Summary: Pygame tilemap editor with collision, animation, sprite & particle tools
 Author: tilemap editor contributors
 License: Proprietary
@@ -18,6 +18,15 @@ Dynamic: license-file
 
 `tilemap-editor` is a pygame-based map editor focused on fast iteration for 2D games.
 
+# tilemap-editor
+
+`tilemap-editor` is a Pygame-based map editor focused on fast iteration for 2D games.
+
+> **Credits:** The initial version of this project was based on DaFluffyPotato's platformer tutorial which is about 6-hours. If you want to understand the foundation this project started from, I highly recommend watching his video: https://www.youtube.com/watch?v=2gABYM5M0ww. While the editor has since evolved with many additional features and improvements, the original map format has been preserved for compatibility.
+
+Several features and design ideas were also inspired by the Godot Engine, including the animation workflow, polygon collision editing, and character collision (Sprite2D-style) editing.
+
+
 ## Installation
 
 [tilemap-editor on PyPI](https://pypi.org/project/tilemap-editor/)
@@ -55,3 +64,6 @@ if __name__ == "__main__":
     editor = Editor()
     editor.run()
 ```
+
+> [!WARNING]
+> The current release requires **Python 3.11+**. The documentation incorrectly lists Python 3.10 support due to an accidental dependency on `typing.NotRequired`. This will be fixed in a future update.

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/README.md

@@ -2,6 +2,15 @@
 
 `tilemap-editor` is a pygame-based map editor focused on fast iteration for 2D games.
 
+# tilemap-editor
+
+`tilemap-editor` is a Pygame-based map editor focused on fast iteration for 2D games.
+
+> **Credits:** The initial version of this project was based on DaFluffyPotato's platformer tutorial which is about 6-hours. If you want to understand the foundation this project started from, I highly recommend watching his video: https://www.youtube.com/watch?v=2gABYM5M0ww. While the editor has since evolved with many additional features and improvements, the original map format has been preserved for compatibility.
+
+Several features and design ideas were also inspired by the Godot Engine, including the animation workflow, polygon collision editing, and character collision (Sprite2D-style) editing.
+
+
 ## Installation
 
 [tilemap-editor on PyPI](https://pypi.org/project/tilemap-editor/)
@@ -39,3 +48,6 @@ if __name__ == "__main__":
     editor = Editor()
     editor.run()
 ```
+
+> [!WARNING]
+> The current release requires **Python 3.11+**. The documentation incorrectly lists Python 3.10 support due to an accidental dependency on `typing.NotRequired`. This will be fixed in a future update.

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

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

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/editor.py

@@ -21,6 +21,7 @@ from constants import BASE_PATH
 from node_manager import NodeManager
 from tilemap import Tilemap
 from utils import error_context, error_handler
+from utils.property_suggestions import PropertySuggestionRegistry
 from utils.standalone import launch_standalone
 from widgets.autotiler import AutotileRuleDesigner
 from widgets.layer_selector import LayerSelector
@@ -212,6 +213,7 @@ class Editor:
         self.regex_automap_designer = RegexAutomapDesigner(self, 150, 100)
         self.notifications = NotificationManager(self)
         self.tooltip = TooltipManager()
+        self.suggestion_registry = PropertySuggestionRegistry()
         self.error_console_process: subprocess.Popen | None = None
         self.property_editor: PropertyEditor | None = None
         self.particle_config_dialog: ParticleConfigDialog | None = None

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/node_manager.py

@@ -13,7 +13,7 @@ def create_node_id() -> str:
     return str(uuid.uuid4())
 
 
-SIDECAR_VERSION = 1
+SIDECAR_VERSION = 2
 
 
 class NodeManager:
@@ -49,10 +49,15 @@ class NodeManager:
             raw = json.loads(sidecar.read_text(encoding="utf-8"))
             if not isinstance(raw, dict):
                 return
+            version = raw.get("version", 1)
             self.groups = list(raw.get("groups", []))
+            rs = self.editor.tilemap.render_scale
             for item in raw.get("nodes", []):
                 if isinstance(item, dict):
                     node = Node.from_dict(item)
+                    if version >= 2:
+                        node.area.x = int(node.area.x * rs)
+                        node.area.y = int(node.area.y * rs)
                     self.nodes[node.node_id] = node
         except (json.JSONDecodeError, KeyError, ValueError, TypeError):
             import logging
@@ -62,12 +67,23 @@ class NodeManager:
     def save(self, map_path: Path) -> None:
         sidecar = self._sidecar_path_for(map_path)
         self.nodes_dir.mkdir(parents=True, exist_ok=True)
-        data: dict[str, Any] = {
-            "version": SIDECAR_VERSION,
-            "groups": self.groups,
-            "nodes": [node.to_dict() for node in self.nodes.values()],
-        }
-        sidecar.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        rs = self.editor.tilemap.render_scale
+        orig_areas: dict[str, tuple[int, int]] = {}
+        for nid, node in self.nodes.items():
+            orig_areas[nid] = (node.area.x, node.area.y)
+            node.area.x = int(node.area.x / rs)
+            node.area.y = int(node.area.y / rs)
+        try:
+            data: dict[str, Any] = {
+                "version": SIDECAR_VERSION,
+                "groups": self.groups,
+                "nodes": [node.to_dict() for node in self.nodes.values()],
+            }
+            sidecar.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        finally:
+            for nid, (ox, oy) in orig_areas.items():
+                self.nodes[nid].area.x = ox
+                self.nodes[nid].area.y = oy
 
     def add_node(self, node: Node) -> str:
         self.nodes[node.node_id] = node

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/plugins/character_collision/editor.py

@@ -182,11 +182,32 @@ class CharacterCollisionEditor:
             self._image_path = self._rel_path(path)
             pygame.display.set_caption(f"Character Collision Editor — {path.stem}")
             self._toast_manager.success(f"Loaded sprite: {path.name}")
+            self._auto_load_collision()
         except Exception as e:
             self._toast_manager.error(f"Failed to load image: {e}")
         finally:
             self._image_dialog = None
 
+    def _auto_load_collision(self) -> bool:
+        name = self._name_input.text.strip()
+        if not name:
+            return False
+        safe = re.sub(r"[^\w\-]+", "-", name).strip("-").lower()
+        coll_filename = f"{safe}.collision.json"
+        try:
+            coll_dir = self._get_collision_dir()
+        except RuntimeError:
+            return False
+        coll_path = coll_dir / coll_filename
+        if coll_path.exists():
+            try:
+                self.load_from_file(coll_path)
+                self._toast_manager.success(f"Loaded collision: {coll_path.name}")
+                return True
+            except Exception:
+                pass
+        return False
+
     def _open_image_dialog(self) -> None:
         try:
             data_root = self._data_root or Path.cwd()
@@ -281,7 +302,6 @@ class CharacterCollisionEditor:
         self.character_name = data.name
         self._name_input.text = data.name
         self._name_input.cursor_pos = len(data.name)
-        self.shape_editor.load_shape_data(data.shape.to_dict())
         layer = data.properties.get("collision_layer", 1)
         mask = data.properties.get("collision_mask", 0xFFFF)
         self.layer_sidebar.set_layer(layer)
@@ -293,7 +313,9 @@ class CharacterCollisionEditor:
             if resolved:
                 self._load_sprite_from_path(resolved)
                 self._toast_manager.success(f"Sprite loaded: {resolved.name}")
-                return
+
+        self.shape_editor.load_shape_data(data.shape.to_dict())
+        return
 
         if data.name:
             for d in [self._data_root]:
@@ -545,6 +567,7 @@ class CharacterCollisionEditor:
         editor = cls(rect, surface, character_name)
         editor._data_root = data_root
         editor._image_path = image_path
+        editor._auto_load_collision()
         return editor
 
     def run(self) -> None:

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/plugins/character_collision/shape_editor.py

@@ -100,6 +100,30 @@ class ShapeEditor:
         self.offset_x = (self.rect.w - sw * self.zoom) / 2
         self.offset_y = (self.rect.h - sh * self.zoom) / 2
 
+    def _focus_on_shape(self) -> None:
+        """Center the viewport on the shape's bounding box"""
+        left, top, right, bottom = self._shape_bounds()
+        cx = (left + right) / 2
+        cy = (top + bottom) / 2
+        self.offset_x = self.rect.w / 2 - cx * self.zoom
+        self.offset_y = self.rect.h / 2 - cy * self.zoom
+
+    def _shape_bounds(self) -> tuple[float, float, float, float]:
+        """Get shape bounding box in sprite-local coords (left, top, right, bottom)"""
+        if self.shape_type == "rectangle":
+            return (self.rect_x, self.rect_y, self.rect_x + self.rect_w, self.rect_y + self.rect_h)
+        if self.shape_type == "circle":
+            return (self.circle_x - self.circle_radius, self.circle_y - self.circle_radius,
+                    self.circle_x + self.circle_radius, self.circle_y + self.circle_radius)
+        if self.shape_type == "capsule":
+            return (self.capsule_x - self.capsule_radius, self.capsule_y,
+                    self.capsule_x + self.capsule_radius, self.capsule_y + self.capsule_height)
+        if self.shape_type == "polygon" and self.polygon_vertices:
+            xs = [v[0] for v in self.polygon_vertices]
+            ys = [v[1] for v in self.polygon_vertices]
+            return (min(xs), min(ys), max(xs), max(ys))
+        return (0, 0, 0, 0)
+
     def _center_shape(self) -> None:
         """Center all shape types on the sprite"""
         sw, sh = self.sprite_surface.get_size()
@@ -195,6 +219,8 @@ class ShapeEditor:
         elif shape_type == "polygon":
             self.polygon_vertices = [tuple(v) for v in data.get("vertices", [])]
 
+        self._focus_on_shape()
+
     def resize(self, rect: Rect) -> None:
         """Update rect"""
         self.rect = rect
@@ -254,12 +280,19 @@ class ShapeEditor:
                     self.hover_handle = None
 
         if event.type == pygame.MOUSEWHEEL and self.rect.collidepoint(mouse):
-            self.zoom *= 1.15 if event.y > 0 else 0.87
-            self.zoom = max(0.5, min(self.zoom, 8.0))
-
-            sprite_pos = self._screen_to_sprite(mouse)
-            self.offset_x = mouse[0] - self.rect.x - sprite_pos[0] * self.zoom
-            self.offset_y = mouse[1] - self.rect.y - sprite_pos[1] * self.zoom
+            mods = pygame.key.get_mods()
+            if mods & (pygame.KMOD_CTRL | pygame.KMOD_META):
+                self.zoom *= 1.15 if event.y > 0 else 0.87
+                self.zoom = max(0.5, min(self.zoom, 8.0))
+                sprite_pos = self._screen_to_sprite(mouse)
+                self.offset_x = mouse[0] - self.rect.x - sprite_pos[0] * self.zoom
+                self.offset_y = mouse[1] - self.rect.y - sprite_pos[1] * self.zoom
+            elif mods & pygame.KMOD_SHIFT:
+                scroll_val = event.y if event.y != 0 else event.x
+                self.offset_x -= scroll_val * 30
+            else:
+                scroll_val = event.y if event.y != 0 else event.x
+                self.offset_y -= scroll_val * 30
             return True
 
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/plugins/object_tileset_collision/editor.py

@@ -234,12 +234,13 @@ class ObjectTilesetCollisionEditor:
     def _layout_toolbar_buttons(self) -> None:
         x = self.toolbar_rect.x + 10
         y = self.toolbar_rect.y + 8
-        for i, btn in enumerate(self._toolbar_buttons):
+        for btn in self._toolbar_buttons:
             if btn.text == "?":
                 w, h = 28, 28
             else:
                 w, h = 60, 28
-            btn.resize(x + i * (w + 8), y, w, h)
+            btn.resize(x, y, w, h)
+            x += w + 8
 
     def _on_splitter_drag(self, pos: int) -> None:
         self.tileset_selector_height = max(

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/plugins/tileset_collision/collision_painter.py

@@ -476,12 +476,19 @@ class CollisionPainter:
                     return True
 
         if event.type == pygame.MOUSEWHEEL and self.rect.collidepoint(mouse):
-            self.zoom *= 1.15 if event.y > 0 else 0.87
-            self.zoom = max(0.5, min(self.zoom, 8.0))
-
-            tile_pos = self._screen_to_tile(mouse)
-            self.offset_x = mouse[0] - self.rect.x - tile_pos[0] * self.zoom
-            self.offset_y = mouse[1] - self.rect.y - tile_pos[1] * self.zoom
+            mods = pygame.key.get_mods()
+            if mods & (pygame.KMOD_CTRL | pygame.KMOD_META):
+                self.zoom *= 1.15 if event.y > 0 else 0.87
+                self.zoom = max(0.5, min(self.zoom, 8.0))
+                tile_pos = self._screen_to_tile(mouse)
+                self.offset_x = mouse[0] - self.rect.x - tile_pos[0] * self.zoom
+                self.offset_y = mouse[1] - self.rect.y - tile_pos[1] * self.zoom
+            elif mods & pygame.KMOD_SHIFT:
+                scroll_val = event.y if event.y != 0 else event.x
+                self.offset_x -= scroll_val * 30
+            else:
+                scroll_val = event.y if event.y != 0 else event.x
+                self.offset_y -= scroll_val * 30
             return True
 
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/plugins/tileset_collision/editor.py

@@ -716,8 +716,18 @@ class TilesetCollisionEditor:
                     return True
 
             if event.type == pygame.MOUSEWHEEL:
-                self.tileset_zoom *= 1.15 if event.y > 0 else 0.87
-                self.tileset_zoom = max(0.5, min(self.tileset_zoom, 8.0))
+                mods = pygame.key.get_mods()
+                if mods & (pygame.KMOD_CTRL | pygame.KMOD_META):
+                    self.tileset_zoom *= 1.15 if event.y > 0 else 0.87
+                    self.tileset_zoom = max(0.5, min(self.tileset_zoom, 8.0))
+                elif mods & pygame.KMOD_SHIFT:
+                    scroll_val = event.y if event.y != 0 else event.x
+                    self.tileset_scroll_x -= scroll_val * 30
+                else:
+                    scroll_val = event.y if event.y != 0 else event.x
+                    self.tileset_scroll_y -= scroll_val * 30
+                self.tileset_scroll_x = max(0, self.tileset_scroll_x)
+                self.tileset_scroll_y = max(0, self.tileset_scroll_y)
                 return True
 
         if event.type == pygame.MOUSEBUTTONUP:
@@ -947,12 +957,17 @@ class TilesetCollisionEditor:
         tw = int(self._tile_size[0] * self.tileset_zoom)
         th = int(self._tile_size[1] * self.tileset_zoom)
 
+        tileset_scr_w = self.tile_cols * tw
+        tileset_scr_h = self.tile_rows * th
+        center_off_x = max(0, (self.tileset_selector_rect.w - tileset_scr_w) // 2)
+        center_off_y = max(0, (self.tileset_selector_rect.h - tileset_scr_h) // 2)
+
         for row in range(self.tile_rows):
             for col in range(self.tile_cols):
                 tile_id = row * self.tile_cols + col
 
-                x = self.tileset_selector_rect.x + col * tw - self.tileset_scroll_x
-                y = self.tileset_selector_rect.y + row * th - self.tileset_scroll_y
+                x = self.tileset_selector_rect.x + col * tw - self.tileset_scroll_x + center_off_x
+                y = self.tileset_selector_rect.y + row * th - self.tileset_scroll_y + center_off_y
 
                 if (
                     x + tw < self.tileset_selector_rect.x

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

@@ -623,6 +623,8 @@ class Tilemap:
             if hasattr(self.editor, "node_selector"):
                 self.editor.node_selector._rebuild_filter()
 
+        if hasattr(self.editor, "suggestion_registry"):
+            self.editor.suggestion_registry.refresh(self.editor)
         self.initialized = True
 
         if self.editor.tile_grid_widget:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 4.3.4
+Version: 4.3.6
 Summary: Pygame tilemap editor with collision, animation, sprite & particle tools
 Author: tilemap editor contributors
 License: Proprietary
@@ -18,6 +18,15 @@ Dynamic: license-file
 
 `tilemap-editor` is a pygame-based map editor focused on fast iteration for 2D games.
 
+# tilemap-editor
+
+`tilemap-editor` is a Pygame-based map editor focused on fast iteration for 2D games.
+
+> **Credits:** The initial version of this project was based on DaFluffyPotato's platformer tutorial which is about 6-hours. If you want to understand the foundation this project started from, I highly recommend watching his video: https://www.youtube.com/watch?v=2gABYM5M0ww. While the editor has since evolved with many additional features and improvements, the original map format has been preserved for compatibility.
+
+Several features and design ideas were also inspired by the Godot Engine, including the animation workflow, polygon collision editing, and character collision (Sprite2D-style) editing.
+
+
 ## Installation
 
 [tilemap-editor on PyPI](https://pypi.org/project/tilemap-editor/)
@@ -55,3 +64,6 @@ if __name__ == "__main__":
     editor = Editor()
     editor.run()
 ```
+
+> [!WARNING]
+> The current release requires **Python 3.11+**. The documentation incorrectly lists Python 3.10 support due to an accidental dependency on `typing.NotRequired`. This will be fixed in a future update.

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -159,6 +159,7 @@ src/utils/icon_manager.py
 src/utils/icons_cache.py
 src/utils/log_capture.py
 src/utils/project_paths.py
+src/utils/property_suggestions.py
 src/utils/serialization.py
 src/utils/standalone.py
 src/utils/validation.py

tilemap_editor-4.3.6/src/utils/property_suggestions.py

@@ -0,0 +1,70 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from editor import Editor
+
+
+class PropertySuggestionRegistry:
+    def __init__(self):
+        self._data: dict[str, list[str]] = {}
+
+    def refresh(self, editor: "Editor"):
+        values: dict[str, set[str]] = {}
+
+        if editor.tileset_widget:
+            for ts in editor.tileset_widget.tilesets:
+                for k, v in ts.properties.items():
+                    values.setdefault(k, set()).add(str(v))
+                for tile_props in ts.tile_properties.values():
+                    for k, v in tile_props.items():
+                        values.setdefault(k, set()).add(str(v))
+
+        if editor.tilemap:
+            for layer in editor.tilemap.layer_manager.layers:
+                for k, v in layer.properties.items():
+                    values.setdefault(k, set()).add(str(v))
+                for tile in layer.tiles.values():
+                    if "properties" in tile:
+                        for k, v in tile["properties"].items():
+                            values.setdefault(k, set()).add(str(v))
+                if layer.layer_type == "object":
+                    for obj in layer.objects.values():
+                        if "properties" in obj:
+                            for k, v in obj["properties"].items():
+                                values.setdefault(k, set()).add(str(v))
+
+        if editor.node_manager:
+            for node in editor.node_manager.nodes.values():
+                for k, v in node.properties.items():
+                    values.setdefault(k, set()).add(str(v))
+
+        self._data = {k: sorted(v) for k, v in values.items()}
+
+    @property
+    def known_keys(self) -> list[str]:
+        return sorted(self._data.keys())
+
+    def ghost_text(self, key: str, input_text: str) -> str:
+        if key not in self._data:
+            return ""
+        prefix = input_text.lower()
+        matches = [
+            v
+            for v in self._data[key]
+            if v.lower().startswith(prefix) and v != input_text
+        ]
+        if matches:
+            return matches[0][len(input_text):]
+        return ""
+
+    def key_ghost(self, input_text: str) -> str:
+        if not input_text:
+            return ""
+        prefix = input_text.lower()
+        matches = [
+            k for k in self._data
+            if k.lower().startswith(prefix) and k != input_text
+        ]
+        if matches:
+            return sorted(matches)[0][len(input_text):]
+        return ""

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

@@ -408,6 +408,7 @@ class LayerSelector:
 
     def _save_layer_properties(self, layer: Layer, props: dict):
         layer.properties = props
+        self.editor.suggestion_registry.refresh(self.editor)
         print(f"Saved properties for layer: {layer.name}")
 
     def draw(self, screen: Surface) -> None:

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/widgets/tile_grid.py

@@ -799,10 +799,12 @@ class TileGrid:
         elif active_layer.layer_type == "object":
             mouse_pos = pygame.mouse.get_pos()
             world_pos = self.screen_to_world(mouse_pos)
+            rs = self.editor.tilemap.render_scale
+            pick_pos = (int(world_pos[0] / rs), int(world_pos[1] / rs)) if rs else world_pos
             for _obj_id, obj in active_layer.get_all_objects().items():
                 area = obj["area"]
                 obj_rect = Rect(area["x"], area["y"], area["w"], area["h"])
-                if obj_rect.collidepoint(world_pos):
+                if obj_rect.collidepoint(pick_pos):
                     ttype = int(obj["ttype"])
                     variant = obj["variant"]
                     ts_widget.select_tile_by_variant(ttype, variant)

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/widgets/tile_selector.py

@@ -416,6 +416,7 @@ class TileSelector(WidgetBase):
                 self._tree.selected_ids = {tileset_data.uid}
                 if tileset_type == "object":
                     self.selected_tile = (0, 0, surf.get_width(), surf.get_height())
+                self.editor.suggestion_registry.refresh(self.editor)
             except Exception as e:
                 error_handler.capture(e, context="load_tileset_surface")
 
@@ -479,6 +480,7 @@ class TileSelector(WidgetBase):
         self._sync_tree()
         self._tree.selected_ids = {tileset_data.uid}
 
+        self.editor.suggestion_registry.refresh(self.editor)
         delattr(self, "_pending_tileset_path")
         delattr(self, "_pending_tileset_surf")
         if self._pending_tileset_queue:
@@ -561,6 +563,7 @@ class TileSelector(WidgetBase):
             if not self.tilesets:
                 self.active_idx = -1
                 self._sync_tree()
+            self.editor.suggestion_registry.refresh(self.editor)
 
     def open_collision_editor(self):
         if self.active_idx == -1 or self.active_idx >= len(self.tilesets):
@@ -573,6 +576,7 @@ class TileSelector(WidgetBase):
 
     def _save_tileset_properties(self, ts: TilesetData, props: dict):
         ts.properties = props
+        self.editor.suggestion_registry.refresh(self.editor)
         print(f"Saved properties for tileset: {ts.name}")
 
     def _save_tile_properties(self, ts: TilesetData, variant_id: int, props: dict):
@@ -582,6 +586,7 @@ class TileSelector(WidgetBase):
     def _save_tile_properties_multi(self, ts: TilesetData, variant_ids: list[int], props: dict):
         for vid in variant_ids:
             ts.tile_properties[vid] = props.copy()
+        self.editor.suggestion_registry.refresh(self.editor)
         if len(variant_ids) == 1:
             print(f"Saved properties for tile {variant_ids[0]} in tileset: {ts.name}")
         else:

{tilemap_editor-4.3.4 → tilemap_editor-4.3.6}/src/widgets/ui/node_editor.py

@@ -356,12 +356,14 @@ class NodeEditor:
         node = self.editor.node_manager.get_active_node()
         if node:
             node.properties = props
+            self.editor.suggestion_registry.refresh(self.editor)
 
     def _save_particle_config(self, cfg: dict):
         node = self.editor.node_manager.get_active_node()
         if node:
             node.properties.clear()
             node.properties.update(cfg)
+            self.editor.suggestion_registry.refresh(self.editor)
             self.editor.tile_grid_widget.reset_particle_preview(node.node_id, cfg)
 
     def draw(self, screen: pygame.Surface):