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

tilemap_editor-4.3.8/CHANGELOG.md

@@ -0,0 +1,231 @@
+# Changelog
+
+<!-- towncrier release notes start -->
+# tilemap_editor 4.3.8 (2026-08-04)
+
+## Features
+
+- Sprite editor: two-row grouped toolbar (no more clipped buttons at the default window size), natural filename sorting on multi-sheet loads, and a Stack V/H toggle for vertical or horizontal sheet stacking. (sprite-editor-toolbar-sort)
+- Rewrote the sprite editor around a command stack with single-canvas undo memory: shared clipboard with relative-tile pasting that survives scale/grid changes, drag-move and rubber-band selection that can expand the canvas, object-selection undo restore, and a pure camera with cursor-anchored zoom. (sprite-editor-v2)
+
+## Bug Fixes
+
+- Fixed sprite editor paste landing in wrong cells after a scale or grid-size change (clipboard now stores relative tile offsets), paste/cut double-clipboard split-brain, paste preview lacking pixel ghost, and moves/pastes past the canvas edge now expanding the canvas. (sprite-editor-paste-fixes)
+- Fixed sprite editor theming and camera gestures: the canvas, header bar, grid lines, and overlays now use theme colors/fonts instead of hardcoded dark values (canvas no longer stays black on light themes), the canvas header no longer covers the sheet's top rows, and mouse wheel zoom/pan work again with the same 30px/1.12x behavior as the old editor. (sprite-editor-theme-wheel)
+
+
+## [4.3.7] - 2026-07-30
+
+### Bug Fixes
+
+- Replaced buggy auto-resize system with explicit offset + size model for widget positioning
+
+## [4.3.6] - 2026-07-26
+
+### Features
+
+- Added tileset properties completion
+- Updated README with credits and Python version info
+
+### Bug Fixes
+
+- Fixed UX bugs and node prescale problem
+
+## [4.3.4] - 2026-07-24
+
+### Features
+
+- Added y-sort option for tile rendering order
+
+### Changed
+
+- Restructured codebase with enhanced UI components and preference persistence
+- Improved shape editor UX with theme integration and viewport centering
+
+## [4.3.1] - 2026-07-17
+
+### Bug Fixes
+
+- Fixed create folder blocker in file manager
+- Adjusted input field inner size
+
+## [4.3.0] - 2026-07-16
+
+### Changed
+
+- Refactored toolbar and tool system with ToolManager/ToolKind central state
+- Replaced editor boolean flags with centralized ToolManager mutual exclusion
+- CLI `--theme` support
+
+### Added
+
+- Icon-only compact toolbar (28px) with separator bars and tooltips
+
+### Bug Fixes
+
+- Fixed node and object render_scale bugs (selection rect, move offset, hit-test)
+
+## [4.2.0] - 2026-07-15
+
+### Features
+
+- Separated autotile group from layer tile data
+- Added global ID system for tiles
+- Re-added autotile early-out optimization
+- Added auto-detect group from variant
+
+## [4.1.0] - 2026-07-13
+
+### Features
+
+- Added .tmx file open/save support with TMX-to-dict converter
+
+### Bug Fixes
+
+- Fixed alignment of tmx converter with parser fixes (mask, props, gid count)
+
+### Misc
+
+- Formatted code and applied unsafe fixes with ruff
+
+## [4.0.0] - 2026-07-11
+
+### Changed
+
+- Refactored widget theme system with dynamic COLORS proxy, SHAPE, FONTS, SPACING
+- Applied theme from settings.json with custom theme loading support
+- Added theme-aware WidgetBase with box model (padding, border, content_rect)
+
+### Added
+
+- CLI `--theme` argument accepting name or path to .json file
+
+### Bug Fixes
+
+- Fixed tile grid issues and serialization
+- Improved node ui/ux with ctrl/cmd+shift+n toggle for node manager
+- Improved particle rendering
+- Temporarily disabled autotile propagation on collision paint
+
+## [3.3.8] - 2026-07-01
+
+### Bug Fixes
+
+- Replaced smoothscale with scale for broader compatibility
+- Fixed fallback to scale when smoothscale fails on non-32bit surfaces
+- Replaced unicode characters with SVG icons for frame nav and onion skin
+
+## [3.3.4] - 2026-06-17
+
+### Features
+
+- Enhanced sprite editor with cut/copy/paste functionality
+- Added checkbox widget for UI controls
+
+### Documentation
+
+- Added documentation for tilemap-editor (setup, project structure, architecture, usage)
+
+## [3.3.3] - 2026-06-10
+
+### Features
+
+- Added particle system with 66 presets across 11 categories
+- Added particle system editor integration with config dialog
+- Added particle preview in TileGrid
+
+### Bug Fixes
+
+- Fixed propagation of negative grid offsets
+- Fixed zero animation frame_stride guard
+- Fixed preset dropdown refresh on node switch
+- Fixed particle preview reset on config save
+
+### Misc
+
+- Added 'synchronize' type to PR agent workflow triggers
+
+## [3.2.10] - 2026-06-07
+
+### Bug Fixes
+
+- Fixed tab click offset ignoring scroll_x
+
+### Added
+
+- Hover-only arrow buttons for tab navigation
+
+## [3.2.9] - 2026-06-07
+
+### Bug Fixes
+
+- Fixed stride normalization — removed % stride normalization, auto-compute stride
+- Fixed dialog UI overlap
+
+## [3.2.8] - 2026-06-07
+
+### Features
+
+- Added node system with NodeManager, NodeSelector, NodeEditor, and TileGrid overlay
+- Added lenient tileset loading with warn dialog instead of reject on size mismatch
+
+### Bug Fixes
+
+- Fixed layer rename text not visible during editing
+- Fixed object layer position offset from render_scale
+- Fixed capsule move icon and animation preview grid_offset
+- Fixed layer rename Cmd+Backspace interaction
+
+## [3.2.4] - 2026-06-04
+
+### Features
+
+- Added copy/paste collision shapes with toast feedback and painted tiles focus mode
+- Added sprite editor integration with flip ghosting fix, tileset zoom, autotiler import fix
+- Added auto-expand spritesheet canvas on paste overflow
+- Added editable name field in character collision editor
+- Added renaming support in character collision
+- Added animation library loading and tool state management
+- Added auto-propagation of collision shapes to auto-tile variant groups on save
+
+### Bug Fixes
+
+- Fixed animation rename shortcuts, path resolution, file input overflow, and dual-focus metadata fields
+- Fixed sprite editor multi-row paste flattening and missing tile-size arg
+- Fixed dynamic grid span
+- Fixed L shortcut conflict with name input
+
+### Misc
+
+- Added unit tests
+
+## [3.1.6] - 2026-05-21
+
+### Bug Fixes
+
+- Fixed NameError in save_map
+- Fixed asymmetry in load path resolution
+- Fixed path resolution in init
+
+### Added
+
+- Added render_scale to map properties with dialog UI and TileGrid support
+- Added auto-creation of data directory on init
+
+## [3.1.0] - 2026-05-18
+
+### Features
+
+- Added Godot-inspired physics layer (radio) + mask (checkbox) bit selector (16 layers)
+- Added collision layer sidebar overlay with toggle/close/dim
+- Added object tileset collision editor with region support
+- Added reusable text input system with cursor, selection, and shortcuts
+- Added project initialization, asset management, and data structure improvements
+- Added theme support
+- Added collision mask support
+- Implemented event priority system and modal overlays in autotiler
+
+### Changed
+
+- Improved file manager path handling and directory initialization
+- Improved tileset collision help panel and macOS HiDPI support

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 4.3.6
+Version: 4.3.8
 Summary: Pygame tilemap editor with collision, animation, sprite & particle tools
 Author: tilemap editor contributors
 License: Proprietary
@@ -12,6 +12,8 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pygame-ce>=2.5
+Provides-Extra: dev
+Requires-Dist: towncrier; extra == "dev"
 Dynamic: license-file
 
 # tilemap-editor

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "4.3.6"
+version = "4.3.8"
 description = "Pygame tilemap editor with collision, animation, sprite & particle tools"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -24,6 +24,41 @@ classifiers = [
 tilemap-editor = "tilemap_editor.cli:main"
 tilemap-anim-editor = "plugins.sprite_animation.standalone:main"
 
+[project.optional-dependencies]
+dev = ["towncrier"]
+
+[tool.towncrier]
+package = "tilemap_editor"
+directory = "changes"
+filename = "CHANGELOG.md"
+start_string = "<!-- towncrier release notes start -->"
+underlines = ["-", "~", "^"]
+
+[[tool.towncrier.type]]
+directory = "feature"
+name = "Features"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "bugfix"
+name = "Bug Fixes"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "doc"
+name = "Documentation"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "removal"
+name = "Deprecations and Removals"
+showcontent = true
+
+[[tool.towncrier.type]]
+directory = "misc"
+name = "Misc"
+showcontent = true
+
 [tool.setuptools]
 package-dir = {"" = "src"}
 include-package-data = true
@@ -62,9 +97,3 @@ namespaces = true
 
 [tool.setuptools.exclude-package-data]
 "*" = ["*.spec", "*.sh"]
-
-# Keep data-files for backward compatibility (one release cycle)
-[tool.setuptools.data-files]
-"share/tilemap_editor/assets/icons" = ["assets/icons/*.svg"]
-"share/tilemap_editor/assets/fonts/noto" = ["assets/fonts/noto/*.ttf"]
-"share/tilemap_editor/assets/fonts/jetbrain-fonts" = ["assets/fonts/jetbrain-fonts/*.ttf"]

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

@@ -39,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
@@ -206,8 +207,7 @@ 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)
@@ -240,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)
@@ -622,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:
@@ -663,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()
@@ -675,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:
@@ -730,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())
@@ -1145,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
@@ -1242,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):
@@ -1259,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
@@ -1310,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()
 
@@ -1341,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:
@@ -1373,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.6 → tilemap_editor-4.3.8}/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.8/src/plugins/sprite_editor/camera.py

@@ -0,0 +1,97 @@
+"""Pure camera math — world (document) <-> screen transforms.
+
+No pygame imports: this module is fully usable and testable headlessly.
+Holds viewport origin and scroll as plain floats; the viewport provides
+the pygame-side rect/bilt machinery.
+"""
+
+from __future__ import annotations
+
+MIN_ZOOM = 0.1
+MAX_ZOOM = 16.0
+
+
+def _clamp_zoom(value: float) -> float:
+    return max(MIN_ZOOM, min(MAX_ZOOM, value))
+
+
+class Camera:
+    """One monotonic linear transform between document and screen space.
+
+    screen = (local - origin) * zoom + viewport_topleft + scroll
+    local  = (screen - viewport_topleft - scroll) / zoom + origin
+    """
+
+    def __init__(
+        self,
+        viewport_x: float = 0.0,
+        viewport_y: float = 0.0,
+        zoom: float = 1.0,
+        scroll_x: float = 0.0,
+        scroll_y: float = 0.0,
+    ):
+        self.viewport_x = float(viewport_x)
+        self.viewport_y = float(viewport_y)
+        self._zoom = _clamp_zoom(float(zoom))
+        self.scroll_x = float(scroll_x)
+        self.scroll_y = float(scroll_y)
+
+    @property
+    def zoom(self) -> float:
+        return self._zoom
+
+    @zoom.setter
+    def zoom(self, value: float) -> None:
+        self._zoom = _clamp_zoom(float(value))
+
+    def world_to_screen(self, x: float, y: float) -> tuple[float, float]:
+        return (
+            self.viewport_x + self.scroll_x + x * self._zoom,
+            self.viewport_y + self.scroll_y + y * self._zoom,
+        )
+
+    def screen_to_world(self, sx: float, sy: float) -> tuple[float, float]:
+        if self._zoom <= 0:
+            return (0.0, 0.0)
+        return (
+            (sx - self.viewport_x - self.scroll_x) / self._zoom,
+            (sy - self.viewport_y - self.scroll_y) / self._zoom,
+        )
+
+    def fit(self, world_size: tuple[float, float], viewport_size: tuple[float, float]) -> None:
+        """Zoom so the whole document fits the viewport, centered."""
+        ww, wh = world_size
+        vw, vh = viewport_size
+        if ww <= 0 or wh <= 0 or vw <= 0 or vh <= 0:
+            self.reset()
+            return
+        self._zoom = _clamp_zoom(min(vw / ww, vh / wh))
+        self.scroll_x = (vw - ww * self._zoom) / 2.0
+        self.scroll_y = (vh - wh * self._zoom) / 2.0
+
+    def reset(self) -> None:
+        """100% zoom, document origin at the viewport top-left."""
+        self._zoom = 1.0
+        self.scroll_x = 0.0
+        self.scroll_y = 0.0
+
+    def zoom_at(self, screen_point: tuple[float, float], factor: float) -> None:
+        """Zoom by factor while keeping the world point under the cursor fixed."""
+        sx, sy = screen_point
+        wx, wy = self.screen_to_world(sx, sy)
+        new_zoom = _clamp_zoom(self._zoom * factor)
+        if abs(new_zoom - self._zoom) < 1e-9:
+            return
+        self._zoom = new_zoom
+        self.scroll_x = sx - self.viewport_x - wx * self._zoom
+        self.scroll_y = sy - self.viewport_y - wy * self._zoom
+
+    def pan(self, dx: float, dy: float) -> None:
+        """Scroll by a screen-space delta (content follows the cursor)."""
+        self.scroll_x += float(dx)
+        self.scroll_y += float(dy)
+
+    def world_to_screen_rect(self, x: float, y: float, w: float, h: float) -> tuple[float, float, float, float]:
+        """Screen-space rect for a world-space rect (floats)."""
+        sx, sy = self.world_to_screen(x, y)
+        return (sx, sy, w * self._zoom, h * self._zoom)