tilemap-editor 4.3.5__tar.gz → 4.3.7__tar.gz

{tilemap_editor-4.3.5/src/tilemap_editor.egg-info → tilemap_editor-4.3.7}/PKG-INFO

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

{tilemap_editor-4.3.5 → tilemap_editor-4.3.7}/pyproject.toml

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

{tilemap_editor-4.3.5 → tilemap_editor-4.3.7}/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
@@ -38,6 +39,7 @@ from widgets.ui.node_selector import NodeSelector
 from widgets.ui.notification import NotificationManager
 from widgets.ui.particle_config_dialog import ParticleConfigDialog
 from widgets.ui.property_editor import PropertyEditor
+from widgets.ui.resize_map_dialog import ResizeMapDialog
 from widgets.ui.sidebar_container import SidebarContainer, ToolbarAction
 from widgets.ui.theme import COLORS, THEMES, get_theme_manager, set_theme
 from widgets.ui.tileset_type_dialog import TilesetTypeDialog
@@ -205,13 +207,13 @@ class Editor:
         self.tile_grid_widget: TileGrid | None = None
 
         self.left_panel_visible = False
-        self.animation_panel: SpriteAnimationEditor | None = None
-        self._animation_panel_surface: pygame.Surface | None = None
+        self.left_panel_w = 300
 
         self.autotiler = AutotileRuleDesigner(self, 100, 100)
         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
@@ -238,6 +240,8 @@ class Editor:
         self.tileset_type_dialog = TilesetTypeDialog(editor_rect)
         self.confirm_dialog = ConfirmDialog(editor_rect)
         self.layer_type_dialog = LayerTypeDialog(editor_rect)
+        self.resize_map_dialog = ResizeMapDialog(editor_rect)
+        self.resize_map_dialog.editor = self
 
         self.menubar = MenuBar(self, self.width, 30)
         self.toolbar = Toolbar(self, 0, 30, self.width, 35)
@@ -620,13 +624,6 @@ class Editor:
 
         self._update_side_panel_layout()
 
-        if self.left_panel_visible and self.animation_panel:
-            panel_rect = Rect(0, menu_h + toolbar_h, self.left_panel_w, height - (menu_h + toolbar_h))
-            if hasattr(self.animation_panel, "rect"):
-                self.animation_panel.rect = panel_rect
-                if hasattr(self.animation_panel, "_relayout"):
-                    self.animation_panel._relayout()
-
         rect_full = Rect(0, 0, width, height)
 
         if hasattr(self, "tileset_type_dialog") and self.tileset_type_dialog:
@@ -661,6 +658,12 @@ class Editor:
             return
         self.map_properties_dialog.open()
 
+    def open_resize_map_dialog(self):
+        if self.resize_map_dialog is None:
+            logger.warning({"msg": "resize_map_dialog is not initialized"})
+            return
+        self.resize_map_dialog.open()
+
     def toggle_autotiler(self):
         if self.autotiler.visible:
             self.autotiler.hide()
@@ -673,47 +676,6 @@ class Editor:
         else:
             self.regex_automap_designer.show()
 
-    def toggle_animation_panel(self):
-        """Toggle the dockable animation panel visibility (Cmd/Ctrl+B)."""
-        if not self.left_panel_visible:
-            if self.animation_panel is None:
-                self._init_animation_panel()
-            if self.animation_panel is not None:
-                self.left_panel_visible = True
-        else:
-            self.left_panel_visible = False
-        self.handle_resize(self.width, self.height)
-
-    def _init_animation_panel(self):
-        """Initialize the animation panel without loading any tileset."""
-        from plugins.sprite_animation.editor import SpriteAnimationEditor
-
-        try:
-
-            class _PanelConsumer:
-                editor_instance = self
-
-                def on_animation_saved(self, name: str, data: dict) -> None:
-                    self.editor_instance.notifications.notify(f"Animation saved: {name}")
-
-                def on_animation_deleted(self, name: str) -> None:
-                    self.editor_instance.notifications.notify(f"Animation deleted: {name}")
-
-            consumer = _PanelConsumer()
-
-            panel_rect = Rect(0, 65, self.left_panel_w, self.height - 65)
-
-            self.animation_panel = SpriteAnimationEditor(
-                panel_rect,
-                surface=None,
-                tile_size=(32, 32),
-                consumer=consumer,
-            )
-            self.animation_panel._data_root = self.data_root
-        except Exception as e:
-            error_handler.capture(e, context="init_animation_panel")
-            self.notifications.notify(f"Failed to init animation panel: {e}")
-
     def undo(self):
         self.tilemap.undo()
         if self.tile_grid_widget:
@@ -728,6 +690,12 @@ class Editor:
         if self.tile_grid_widget:
             self.tile_grid_widget.show_grid = not self.tile_grid_widget.show_grid
 
+    def toggle_map_boundary(self):
+        if self.tile_grid_widget:
+            self.tile_grid_widget.show_map_boundary = (
+                not self.tile_grid_widget.show_map_boundary
+            )
+
     def cycle_theme(self):
         """Cycle through available themes."""
         theme_names = list(THEMES.keys())
@@ -1143,6 +1111,10 @@ class Editor:
                 self.layer_type_dialog.handle_event(event)
                 continue
 
+            if self.resize_map_dialog and self.resize_map_dialog.active:
+                self.resize_map_dialog.handle_event(event)
+                continue
+
             if self.map_setup_widget and self.map_setup_widget.visible:
                 if self.map_setup_widget.handle_event(event):
                     continue
@@ -1240,7 +1212,7 @@ class Editor:
                     self.cycle_theme()
                     continue
                 if event.key == pygame.K_b and (ctrl_held or meta_held):
-                    self.toggle_animation_panel()
+                    self.toggle_map_boundary()
                     continue
                 if pygame.K_1 <= event.key <= pygame.K_9:
                     if not (self.node_editor and self.node_editor.visible and self.node_editor.editing_field):
@@ -1257,11 +1229,6 @@ class Editor:
             if self.toolbar and self.toolbar.handle_event(event):
                 continue
 
-            if self.left_panel_visible and self.animation_panel:
-                if hasattr(self.animation_panel, "handle_event"):
-                    if self.animation_panel.handle_event(event):
-                        continue
-
             if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
                 mx, my = event.pos
                 edge_x = self.width - self._effective_selector_w
@@ -1308,10 +1275,6 @@ class Editor:
             if self.tile_grid_widget:
                 self.tile_grid_widget.update()
 
-            if self.left_panel_visible and self.animation_panel:
-                if hasattr(self.animation_panel, "update"):
-                    self.animation_panel.update()
-
             self.screen.fill(COLORS.bg)
             self.tooltip.hide()
 
@@ -1339,20 +1302,6 @@ class Editor:
                     self.screen.blit(overlay, (0, 0))
                 self.regex_automap_designer.draw(self.screen)
 
-            if self.left_panel_visible and self.animation_panel:
-                panel_surf = pygame.Surface((self.left_panel_w, self.height), pygame.SRCALPHA)
-                panel_surf.fill((*COLORS.panel_alt, 255))
-                self.screen.blit(panel_surf, (0, 65))
-
-                pygame.draw.rect(
-                    self.screen,
-                    COLORS.border,
-                    Rect(0, 65, self.left_panel_w, self.height - 65),
-                    1,
-                )
-                if hasattr(self.animation_panel, "draw"):
-                    self.animation_panel.draw(self.screen)
-
             self.notifications.draw(self.screen)
 
             if self.map_setup_widget and self.map_setup_widget.visible:
@@ -1371,16 +1320,18 @@ class Editor:
                 overlay.fill((0, 0, 0, 150))
                 self.screen.blit(overlay, (0, 0))
                 self.tileset_type_dialog.draw(self.screen)
-            if self.confirm_dialog.active:
+            if self.resize_map_dialog and self.resize_map_dialog.active:
+                self.resize_map_dialog.draw(self.screen)
+            if self.layer_type_dialog.active:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
                 overlay.fill((0, 0, 0, 150))
                 self.screen.blit(overlay, (0, 0))
-                self.confirm_dialog.draw(self.screen)
-            if self.layer_type_dialog.active:
+                self.layer_type_dialog.draw(self.screen)
+            if self.confirm_dialog.active:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
                 overlay.fill((0, 0, 0, 150))
                 self.screen.blit(overlay, (0, 0))
-                self.layer_type_dialog.draw(self.screen)
+                self.confirm_dialog.draw(self.screen)
 
             if self.loading_state["active"]:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)

{tilemap_editor-4.3.5 → tilemap_editor-4.3.7}/src/layers.py

@@ -217,6 +217,7 @@ class Layer:
         start_pos: tuple[int, int],
         new_tile_data: TypeTile,
         map_size: tuple[int, int],
+        offset: tuple[int, int] = (0, 0),
     ) -> None:
         """Replace contiguous tiles of the same type starting from start_pos."""
         if self.locked or self.layer_type != "tile":
@@ -238,7 +239,13 @@ class Layer:
         while queue:
             curr = queue.pop(0)
 
-            if curr[0] < 0 or curr[0] >= map_size[0] or curr[1] < 0 or curr[1] >= map_size[1]:
+            ox, oy = offset
+            if (
+                curr[0] < ox
+                or curr[0] >= ox + map_size[0]
+                or curr[1] < oy
+                or curr[1] >= oy + map_size[1]
+            ):
                 continue
 
             curr_tile = self.tiles.get(curr)

{tilemap_editor-4.3.5 → tilemap_editor-4.3.7}/src/tilemap.py

@@ -40,7 +40,7 @@ class Tilemap:
 
         self.tile_size = (32, 32)
         self.map_size = (50, 50)
-        self.initial_map_size = (50, 50)
+        self.offset = (0, 0)
         self.initialized = False
         self.render_scale = 1.0
 
@@ -62,10 +62,10 @@ class Tilemap:
         if active_layer:
             active_layer.tiles = value
 
-    def init_size(self, tile_size: "TCoor", map_size: "TCoor", render_scale: float = 1.0):
+    def init_size(self, tile_size: "TCoor", map_size: "TCoor", offset: "TCoor" = (0, 0), render_scale: float = 1.0):
         self.tile_size = tile_size
         self.map_size = map_size
-        self.initial_map_size = map_size
+        self.offset = offset
         self.initialized = True
         self.render_scale = render_scale
         self.active_project_path = None
@@ -88,6 +88,7 @@ class Tilemap:
             "active_layer_idx": self.layer_manager.active_layer_idx,
             "tile_size": self.tile_size,
             "map_size": self.map_size,
+            "offset": self.offset,
             "render_scale": self.render_scale,
         }
         self.history.save_state(state, description)
@@ -105,6 +106,7 @@ class Tilemap:
             "active_layer_idx": self.layer_manager.active_layer_idx,
             "tile_size": self.tile_size,
             "map_size": self.map_size,
+            "offset": self.offset,
             "render_scale": self.render_scale,
         }
         prev_state = self.history.undo(current_state)
@@ -124,6 +126,7 @@ class Tilemap:
             "active_layer_idx": self.layer_manager.active_layer_idx,
             "tile_size": self.tile_size,
             "map_size": self.map_size,
+            "offset": self.offset,
             "render_scale": self.render_scale,
         }
         next_state = self.history.redo(current_state)
@@ -131,28 +134,7 @@ class Tilemap:
             self._apply_history_state(next_state)
 
     def update_map_size(self):
-        """Full scan to recalculate map size based on all layers."""
-        if not self.initialized:
-            return
-
-        max_w = self.initial_map_size[0]
-        max_h = self.initial_map_size[1]
-
-        for layer in self.layer_manager.layers:
-            if layer.tiles:
-                for pos in layer.tiles:
-                    max_w = max(max_w, pos[0] + 1)
-                    max_h = max(max_h, pos[1] + 1)
-
-            if layer.objects:
-                for obj in layer.objects.values():
-                    area = obj["area"]
-                    grid_r = (area["x"] + area["w"]) / self.tile_size[0]
-                    grid_b = (area["y"] + area["h"]) / self.tile_size[1]
-                    max_w = max(max_w, int(grid_r) + 1)
-                    max_h = max(max_h, int(grid_b) + 1)
-
-        self.map_size = (max_w, max_h)
+        """Deprecated compatibility hook retained as no-op."""
 
     def incremental_update_map_size(
         self,
@@ -160,22 +142,15 @@ class Tilemap:
         is_pixel: bool = False,
         size: tuple[int, int] | None = None,
     ):
-        """Update map size based on a single point or area without full scan."""
-        if not self.initialized:
-            return
-
-        if is_pixel:
-            w, h = size if size else self.tile_size
-            grid_r = int((pos[0] + w) / self.tile_size[0]) + 1
-            grid_b = int((pos[1] + h) / self.tile_size[1]) + 1
-            new_w = max(self.map_size[0], grid_r)
-            new_h = max(self.map_size[1], grid_b)
-        else:
-            new_w = max(self.map_size[0], pos[0] + 1)
-            new_h = max(self.map_size[1], pos[1] + 1)
+        """Deprecated compatibility hook retained as no-op."""
 
-        if (new_w, new_h) != self.map_size:
-            self.map_size = (new_w, new_h)
+    def resize(self, offset: "TCoor", size: "TCoor"):
+        """Manually set the map offset and size."""
+        self.offset = offset
+        self.map_size = (max(1, size[0]), max(1, size[1]))
+        tile_grid_widget = getattr(self.editor, "tile_grid_widget", None)
+        if tile_grid_widget is not None and hasattr(tile_grid_widget, "invalidate_bounds_cache"):
+            tile_grid_widget.invalidate_bounds_cache()
 
     def _apply_history_state(self, state):
         from layers import Layer
@@ -185,6 +160,7 @@ class Tilemap:
         self.layer_manager.active_layer_idx = state["active_layer_idx"]
         self.tile_size = state["tile_size"]
         self.map_size = state["map_size"]
+        self.offset = state.get("offset", (0, 0))
         self.render_scale = state.get("render_scale", 1.0)
 
         if hasattr(self.editor, "autotiler"):
@@ -259,7 +235,7 @@ class Tilemap:
                         (getattr(self.editor.tile_grid_widget, "scroll_y", 0) if self.editor.tile_grid_widget else 0),
                     )
                 ),
-                "initial_map_size": serialize_point(self.initial_map_size),
+                "offset": serialize_point(self.offset),
                 "render_scale": self.render_scale,
                 "version": "1.1",
             },
@@ -470,11 +446,7 @@ class Tilemap:
             self.tile_size = deserialize_point(payload["meta"]["tile_size"])
             self.map_size = deserialize_point(payload["meta"].get("map_size", "50;50"))
 
-            self.initial_map_size = payload["meta"].get("initial_map_size")
-            if self.initial_map_size:
-                self.initial_map_size = deserialize_point(self.initial_map_size)
-            else:
-                self.initial_map_size = self.map_size
+            self.offset = deserialize_point(payload["meta"].get("offset", "0;0"))
             self.render_scale = float(payload["meta"].get("render_scale", 1.0))
         except (KeyError, ValueError) as e:
             raise ValueError(f"Error loading map metadata: {e}") from e
@@ -576,8 +548,8 @@ class Tilemap:
                 designer.groups.append(AutotileGroup("Default"))
             designer.selected_group_idx = 0
 
-        if hasattr(self.editor, "regex_automap_designer") and self.editor.regex_automap_designer:
-            if "project_state" in payload and "automap_rules" in payload["project_state"]:
+        if (hasattr(self.editor, "regex_automap_designer") and self.editor.regex_automap_designer
+                and "project_state" in payload and "automap_rules" in payload["project_state"]):
                 try:
                     automap_rules_data = payload["project_state"]["automap_rules"]
                     if isinstance(automap_rules_data, list):
@@ -623,6 +595,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:
@@ -754,7 +728,7 @@ class Tilemap:
         meta = {
             "tile_size": f"{tile_w},{tile_h}",
             "map_size": f"{map_w},{map_h}",
-            "initial_map_size": f"{map_w},{map_h}",
+            "offset": "0,0",
             "render_scale": 1.0,
             "version": "1.1",
             "zoom_level": 1.0,

{tilemap_editor-4.3.5 → tilemap_editor-4.3.7/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-4.3.5 → tilemap_editor-4.3.7}/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
@@ -197,6 +198,7 @@ src/widgets/ui/notification.py
 src/widgets/ui/particle_config_dialog.py
 src/widgets/ui/property_editor.py
 src/widgets/ui/region_selector.py
+src/widgets/ui/resize_map_dialog.py
 src/widgets/ui/scrollbar.py
 src/widgets/ui/sidebar_container.py
 src/widgets/ui/splitter.py
@@ -215,6 +217,7 @@ tests/test_drag_tracker.py
 tests/test_editor_pan_mode.py
 tests/test_gid_collision.py
 tests/test_layers_autotile.py
+tests/test_map_resize_model.py
 tests/test_project_paths.py
 tests/test_render_scale.py
 tests/test_serialization_regression.py

{tilemap_editor-4.3.5 → tilemap_editor-4.3.7}/src/utils/font_manager.py

@@ -109,6 +109,10 @@ class FontManager:
         bold: bool | None = None,
         italic: bool | None = None,
     ) -> pygame.font.Font:
+        if not pygame.get_init():
+            pygame.init()
+        if not pygame.font.get_init():
+            pygame.font.init()
         """
         Get a font with specified properties.
 

tilemap_editor-4.3.7/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.5 → tilemap_editor-4.3.7}/src/widgets/input.py

@@ -148,9 +148,8 @@ class InputBox(WidgetBase):
                 self.insert_text(event.unicode)
                 return True
 
-        if self.is_focused and event.type == pygame.KEYUP:
-            if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
-                self.selection_start = None
+        if self.is_focused and event.type == pygame.KEYUP and event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
+            self.selection_start = None
 
         return False
 
@@ -442,9 +441,8 @@ class InlineTextInput:
                 self.insert_text(event.unicode)
                 return True
 
-        if event.type == pygame.KEYUP:
-            if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
-                self.selection_start = None
+        if event.type == pygame.KEYUP and event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
+            self.selection_start = None
 
         return False
 
@@ -470,3 +468,30 @@ class DigitInput(BaseTextInput):
 
     def get_value(self) -> int:
         return self.get_int_value()
+
+
+class SignedIntInput(BaseTextInput):
+    def __init__(
+        self,
+        rect: Rect,
+        label: str,
+        key: str,
+        default_val: str = "",
+        tab_index: int | None = None,
+    ):
+        super().__init__(
+            rect,
+            label,
+            key,
+            default_val,
+            tab_index,
+            allowed_chars="-0123456789",
+        )
+
+    def is_char_allowed(self, char: str) -> bool:
+        if char in "-":
+            return self.text == ""
+        return char.isdigit()
+
+    def get_value(self) -> int:
+        return self.get_int_value()

{tilemap_editor-4.3.5 → tilemap_editor-4.3.7}/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: