tilemap-editor 3.2.10__tar.gz → 3.3.1__tar.gz

{tilemap_editor-3.2.10/src/tilemap_editor.egg-info → tilemap_editor-3.3.1}/PKG-INFO

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

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.2.10"
+version = "3.3.1"
 description = "Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -32,6 +32,8 @@ py-modules = [
   "editor",
   "event_map",
   "layers",
+  "node_manager",
+  "nodes",
   "tilemap",
   "standalone_filemanager",
   "standalone_image_viewer",

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/src/editor.py

@@ -242,7 +242,7 @@ class Editor:
         center_x = (self.width - 400) // 2
         center_y = (self.height - 400) // 2
         self.map_setup_widget = MapSetup(self, Rect(center_x, center_y, 400, 400))
-        self.map_setup_widget.visible = False
+        self.map_setup_widget.visible = True
         self.map_properties_dialog = MapPropertiesDialog(self, Rect(center_x, center_y, 400, 260))
         self.node_manager = NodeManager(self)
         self.node_selector = NodeSelector(self, 0, 65, 260, 240)
@@ -442,6 +442,67 @@ class Editor:
         except Exception as e:
             error_handler.capture(e, context="save_map_selected")
 
+    def export_selection_as_png(self):
+        rect = self.tile_grid_widget.selection_rect
+        if rect is None:
+            self.notifications.notify("No region selected", duration=2.0)
+            return
+        self.open_file_manager(
+            on_save=self._on_export_selection_png,
+            allowed_exts=[".png"],
+            mode="save",
+            default_name="selection.png",
+        )
+
+    def _on_export_selection_png(self, path: Path):
+        rect = self.tile_grid_widget.selection_rect
+        if rect is None:
+            return
+        x1, y1, x2, y2 = rect
+        tw, th = self.tilemap.tile_size
+        pw = (x2 - x1 + 1) * tw
+        ph = (y2 - y1 + 1) * th
+        if pw <= 0 or ph <= 0:
+            return
+
+        export_surf = pygame.Surface((pw, ph), pygame.SRCALPHA)
+        layers = self.tilemap.layer_manager.get_rendered_layers()
+        tileset_map = self.tileset_widget.tileset_map
+
+        for layer in layers:
+            if layer.layer_type != "tile":
+                continue
+            if layer.opacity < 1.0:
+                layer_surf = pygame.Surface((pw, ph), pygame.SRCALPHA)
+            else:
+                layer_surf = export_surf
+
+            for (gx, gy), tile in layer.tiles.items():
+                if not (x1 <= gx <= x2 and y1 <= gy <= y2):
+                    continue
+                dx = (gx - x1) * tw
+                dy = (gy - y1) * th
+                ttype = int(tile["ttype"])
+                if ttype not in tileset_map:
+                    continue
+                ts = tileset_map[ttype]
+                variant_id = tile["variant"]
+                sheet_w = ts.surface.get_width()
+                sheet_cols = sheet_w // tw
+                src_x = (variant_id % sheet_cols) * tw
+                src_y = (variant_id // sheet_cols) * th
+                src_rect = Rect(src_x, src_y, tw, th)
+                if not ts.surface.get_rect().contains(src_rect):
+                    continue
+                layer_surf.blit(ts.surface, (dx, dy), src_rect)
+
+            if layer.opacity < 1.0:
+                layer_surf.set_alpha(int(layer.opacity * 255))
+                export_surf.blit(layer_surf, (0, 0))
+
+        pygame.image.save(export_surf, str(path))
+        self.notifications.notify(f"Exported selection to {path.name}", duration=2.0)
+
     def perform_load(self):
         self.open_file_manager(
             on_select=self.on_map_file_selected,
@@ -771,23 +832,14 @@ class Editor:
             error_handler.capture(e, context="launch_animation_editor")
 
     def launch_sprite_editor(self):
-        """Launch the sprite editor in a new window."""
-        self.open_file_manager(
-            on_select=self._launch_sprite_editor_with_image,
-            initial_dir=self.data_root,
-            allowed_exts=[".png", ".jpg", ".jpeg"],
-            mode="open",
-        )
-
-    def _launch_sprite_editor_with_image(self, path: Path):
-        """Launch sprite editor subprocess with selected image."""
+        """Launch the sprite editor (blank) in a new window. Use [Open] inside to load sheets."""
         try:
             tile_size = "32x32"
             if hasattr(self.tilemap, "tile_size") and self.tilemap.tile_size:
                 tw, th = self.tilemap.tile_size
                 tile_size = f"{tw}x{th}"
 
-            args = [str(path), "--tile-size", tile_size, "--data-root", str(self.data_root)]
+            args = ["--tile-size", tile_size, "--data-root", str(self.data_root)]
             process = launch_standalone(
                 "plugins.sprite_editor.standalone",
                 args,
@@ -1161,6 +1213,9 @@ class Editor:
                 elif event.mod & pygame.KMOD_CTRL and event.key == pygame.K_g:
                     self.toggle_grid()
                     continue
+                elif event.key == pygame.K_e and ctrl_held and shift_held:
+                    self.export_selection_as_png()
+                    continue
                 elif event.key == pygame.K_t and (ctrl_held or meta_held):
                     self.cycle_theme()
                     continue

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/src/plugins/sprite_editor/editor.py

@@ -2,16 +2,16 @@
 SpriteEditor — standalone widget wrapping SpritesheetGrid with editing toolbar.
 
 Toolbar:
-  [Flip X] [Flip Y] [Copy] [Paste] [Undo] [Redo] [Scale...] [Save PNG]
+  [Flip X] [Flip Y] [Copy] [Paste] [Undo] [Redo] [Scale...] [Grid WxH] [Open] [Save PNG]
 """
 
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, Optional
+from typing import Dict, List, Optional, Union
 
 import pygame
-from pygame import Rect, Surface
+from pygame import Rect, Surface, SRCALPHA
 
 from widgets.spritesheet_grid import SpritesheetGrid
 from widgets.ui.theme import COLORS
@@ -34,6 +34,8 @@ _BUTTON_ICONS: dict[str, str | None] = {
     "Undo": None,
     "Redo": None,
     "Scale": None,
+    "Grid": None,
+    "Open": None,
     "Save": "save",
 }
 
@@ -42,8 +44,8 @@ class SpriteEditor:
     def __init__(
         self,
         rect: Rect,
-        surface: Surface,
-        tile_size: tuple[int, int],
+        surface: Optional[Surface] = None,
+        tile_size: tuple[int, int] = (32, 32),
         image_path: Optional[Path] = None,
         data_root: Optional[Path] = None,
     ):
@@ -51,9 +53,17 @@ class SpriteEditor:
         self.image_path = image_path
         self._data_root = data_root or (image_path.parent if image_path else Path.cwd())
 
+        # Start blank if no surface provided; track real sheets separately
+        if surface is None:
+            placeholder = Surface((1, 1), SRCALPHA)
+            self._sheet_surfaces: List[Surface] = []
+        else:
+            placeholder = surface
+            self._sheet_surfaces = [surface]
+
         # Grid
         grid_rect = Rect(rect.x, rect.y + TOOLBAR_H, rect.w, rect.h - TOOLBAR_H - STATUS_H)
-        self.grid = SpritesheetGrid(grid_rect, surface, tile_size)
+        self.grid = SpritesheetGrid(grid_rect, placeholder, tile_size)
 
         # Clipboard for copy/paste
         self._clipboard: Dict[int, Surface] = {}
@@ -64,6 +74,11 @@ class SpriteEditor:
         self._scale_text: str = "2.0"
         self._scale_error: Optional[str] = None
 
+        # Grid dialog state
+        self._grid_active: bool = False
+        self._grid_text: str = f"{tile_size[0]}x{tile_size[1]}"
+        self._grid_error: Optional[str] = None
+
         # Save path — never auto-overwrite original
         self._save_path: Optional[Path] = None
 
@@ -81,13 +96,19 @@ class SpriteEditor:
         ty = self.rect.y + (TOOLBAR_H - BTN_H) // 2
         gap = 6
         x = self.rect.x + gap
-        labels = ["Flip X", "Flip Y", "Copy", "Paste", "Undo", "Redo", "Scale", "Save"]
+        labels = ["Flip X", "Flip Y", "Copy", "Paste", "Undo", "Redo", "Scale", "Grid", "Open", "Save"]
         for lbl in labels:
             self._btn_rects[lbl] = Rect(x, ty, BTN_W, BTN_H)
             x += BTN_W + gap
 
     def _get_status_text(self) -> str:
-        parts = [f"Zoom: {self.grid.zoom:.1f}x"]
+        n = len(self._sheet_surfaces)
+        if n == 0:
+            return "  No spritesheets loaded  —  Click [Open] to load one or more sheets"
+        tw, th = self.grid.tile_size
+        parts = [f"Tile: {tw}×{th}  Zoom: {self.grid.zoom:.1f}x"]
+        if n > 1:
+            parts.append(f"Sheets: {n}")
         sel = len(self.grid.selected_indices)
         if sel:
             parts.append(f"Selected: {sel}")
@@ -109,6 +130,9 @@ class SpriteEditor:
         if self._scale_active:
             return self._handle_scale_dialog(event)
 
+        if self._grid_active:
+            return self._handle_grid_dialog(event)
+
         mouse = pygame.mouse.get_pos()
 
         # Keyboard shortcuts
@@ -182,6 +206,15 @@ class SpriteEditor:
             self._scale_text = "2.0"
             self._scale_error = None
             return True
+        elif lbl == "Grid":
+            self._grid_active = True
+            tw, th = self.grid.tile_size
+            self._grid_text = f"{tw}x{th}"
+            self._grid_error = None
+            return True
+        elif lbl == "Open":
+            self._open_add_sheets_dialog()
+            return True
         elif lbl == "Save":
             self._open_save_dialog()
             return True
@@ -213,6 +246,44 @@ class SpriteEditor:
                 return True
         return False
 
+    def _handle_grid_dialog(self, event: pygame.event.Event) -> bool:
+        if event.type == pygame.KEYDOWN:
+            if event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
+                parts = self._grid_text.lower().split("x")
+                try:
+                    tw = int(parts[0])
+                    th = int(parts[1]) if len(parts) > 1 else tw
+                    if tw < 1 or th < 1:
+                        self._grid_error = "Must be >= 1"
+                    else:
+                        self.grid.set_tile_size(tw, th)
+                        self._grid_active = False
+                        self._grid_error = None
+                except ValueError:
+                    self._grid_error = "Use format: WxH or N"
+                return True
+            elif event.key == pygame.K_ESCAPE:
+                self._grid_active = False
+                self._grid_error = None
+                return True
+            elif event.key == pygame.K_BACKSPACE:
+                self._grid_text = self._grid_text[:-1]
+                return True
+            elif event.unicode and event.unicode in "0123456789xX" and len(self._grid_text) < 10:
+                self._grid_text += event.unicode
+                return True
+        return False
+
+    @staticmethod
+    def _detect_tile_size(surface: Surface) -> tuple[int, int]:
+        w, h = surface.get_size()
+        candidates = [8, 12, 16, 24, 32, 48, 64, 128]
+        best = 8
+        for s in candidates:
+            if w % s == 0 and h % s == 0:
+                best = s
+        return (best, best)
+
     def _open_save_dialog(self) -> None:
         """Open FileManager in save mode to pick a PNG path."""
         from widgets.filemanager import FileManager
@@ -253,6 +324,64 @@ class SpriteEditor:
     def set_save_path(self, path: Path) -> None:
         self._save_path = path
 
+    # ------------------------------------------------------------------
+    # Multi-sheet: stack sheets vertically into one combined surface
+    # ------------------------------------------------------------------
+
+    def _build_combined_surface(self) -> None:
+        """Rebuild the combined surface from all loaded sheets (stacked vertically)."""
+        n = len(self._sheet_surfaces)
+        if n == 0:
+            return
+        if n == 1:
+            self.grid.set_surface(self._sheet_surfaces[0])
+            return
+
+        max_w = max(s.get_width() for s in self._sheet_surfaces)
+        total_h = sum(s.get_height() for s in self._sheet_surfaces)
+        combined = Surface((max_w, total_h), SRCALPHA)
+        combined.fill((0, 0, 0, 0))
+        y = 0
+        for surf in self._sheet_surfaces:
+            combined.blit(surf, (0, y))
+            y += surf.get_height()
+        self.grid.set_surface(combined)
+
+    def _open_add_sheets_dialog(self) -> None:
+        """Open FileManager in multi-select mode to pick one or more sheets."""
+        from widgets.filemanager import FileManager
+
+        fm_rect = self._file_manager_rect()
+        self._file_manager = FileManager(
+            rect=fm_rect,
+            initial_dir=self._data_root,
+            allowed_exts=[".png", ".jpg", ".jpeg", ".bmp", ".gif"],
+            on_select=self._on_add_sheets,
+            mode="open",
+            on_cancel=self._close_file_manager,
+            multi_select=True,
+            data_root=self._data_root,
+        )
+
+    def _on_add_sheets(self, selection: Union[Path, List[Path]]) -> None:
+        if isinstance(selection, Path):
+            selection = [selection]
+        was_empty = len(self._sheet_surfaces) == 0
+        loaded = 0
+        for path in selection:
+            try:
+                surf = pygame.image.load(str(path)).convert_alpha()
+                self._sheet_surfaces.append(surf)
+                loaded += 1
+            except Exception as e:
+                print(f"Failed to load {path.name}: {e}")
+        if loaded:
+            if was_empty:
+                detected = self._detect_tile_size(self._sheet_surfaces[0])
+                self.grid.set_tile_size(*detected)
+            self._build_combined_surface()
+        self._close_file_manager()
+
     # ------------------------------------------------------------------
     # Drawing
     # ------------------------------------------------------------------
@@ -295,6 +424,8 @@ class SpriteEditor:
 
         if self._scale_active:
             self._draw_scale_dialog(screen)
+        if self._grid_active:
+            self._draw_grid_dialog(screen)
 
         # File manager overlay
         if self._file_manager is not None:
@@ -321,3 +452,25 @@ class SpriteEditor:
 
         hint = self._font_sm.render("Enter / Esc", True, COLORS.text_dim)
         screen.blit(hint, (dlg.right - 90, dlg.bottom - 22))
+
+    def _draw_grid_dialog(self, screen: Surface) -> None:
+        dw, dh = 260, 100
+        cx, cy = self.rect.center
+        dlg = Rect(cx - dw // 2, cy - dh // 2, dw, dh)
+        draw_panel(screen, dlg, COLORS.panel, COLORS.border)
+
+        title = self._font.render("Tile Size (WxH)", True, COLORS.text)
+        screen.blit(title, title.get_rect(centerx=dlg.centerx, top=dlg.top + 10))
+
+        inp = Rect(dlg.x + 20, dlg.top + 36, dw - 40, 28)
+        pygame.draw.rect(screen, COLORS.selected, inp, border_radius=4)
+        pygame.draw.rect(screen, COLORS.accent, inp, 2, border_radius=4)
+        txt = self._grid_text + ("|" if (pygame.time.get_ticks() // 400) % 2 else "")
+        screen.blit(self._font_sm.render(txt, True, COLORS.text), (inp.x + 6, inp.y + 5))
+
+        if self._grid_error:
+            err = self._font_sm.render(self._grid_error, True, COLORS.danger)
+            screen.blit(err, (dlg.x + 20, dlg.bottom - 22))
+
+        hint = self._font_sm.render("Enter / Esc", True, COLORS.text_dim)
+        screen.blit(hint, (dlg.right - 90, dlg.bottom - 22))

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/src/plugins/sprite_editor/standalone.py

@@ -2,9 +2,9 @@
 Standalone launcher for the Sprite Editor.
 
 Usage:
+    python standalone.py                          # start blank, then click [Open]
     python standalone.py path/to/spritesheet.png
     python standalone.py path/to/spritesheet.png --tile-size 32
-    python standalone.py path/to/spritesheet.png --save output.png
 """
 
 from __future__ import annotations
@@ -47,7 +47,8 @@ def main(argv: list[str] | None = None) -> None:
     sys.excepthook = handle_exception
 
     parser = argparse.ArgumentParser(description="Grid Sprite Editor")
-    parser.add_argument("image", type=str, help="Path to spritesheet image")
+    parser.add_argument("image", type=str, nargs="?", default=None,
+                        help="Path to spritesheet image (optional — start blank)")
     parser.add_argument("--tile-size", type=str, default="32",
                         help="Tile size (e.g. 32 or 32x32)")
     parser.add_argument("--save", type=str, default=None,
@@ -59,30 +60,35 @@ def main(argv: list[str] | None = None) -> None:
 
     args = parser.parse_args(argv)
 
-    image_path = Path(args.image)
-    if not image_path.is_file():
-        print(f"Error: file not found: {image_path}")
-        sys.exit(1)
-
     ts_parts = args.tile_size.lower().split("x")
     tw = int(ts_parts[0])
     th = int(ts_parts[1]) if len(ts_parts) > 1 else tw
 
     window_size = parse_window_size(args.window_size)
-    data_root = Path(args.data_root) if args.data_root else image_path.parent
 
     pygame.init()
     screen = pygame.display.set_mode(window_size, pygame.RESIZABLE)
-    pygame.display.set_caption(f"Sprite Editor - {image_path.name}")
-
-    surface = pygame.image.load(str(image_path)).convert_alpha()
 
-    editor = SpriteEditor(
-        screen.get_rect(), surface, (tw, th),
-        image_path=image_path, data_root=data_root,
-    )
-    if args.save:
-        editor.set_save_path(Path(args.save))
+    if args.image:
+        image_path = Path(args.image)
+        if not image_path.is_file():
+            print(f"Error: file not found: {image_path}")
+            sys.exit(1)
+        data_root = Path(args.data_root) if args.data_root else image_path.parent
+        surface = pygame.image.load(str(image_path)).convert_alpha()
+        pygame.display.set_caption(f"Sprite Editor - {image_path.name}")
+        editor = SpriteEditor(
+            screen.get_rect(), surface, (tw, th),
+            image_path=image_path, data_root=data_root,
+        )
+        if args.save:
+            editor.set_save_path(Path(args.save))
+    else:
+        data_root = Path(args.data_root) if args.data_root else Path.cwd()
+        pygame.display.set_caption("Sprite Editor — blank")
+        editor = SpriteEditor(
+            screen.get_rect(), tile_size=(tw, th), data_root=data_root,
+        )
 
     clock = pygame.time.Clock()
     running = True

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/src/tilemap_editor.egg-info/top_level.txt

@@ -3,6 +3,8 @@ constants
 editor
 event_map
 layers
+node_manager
+nodes
 plugins
 standalone_automap
 standalone_error_console

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/src/widgets/filemanager.py

@@ -503,6 +503,7 @@ class FileManager:
 
         self.font_main = pygame.font.SysFont("Arial", 14)
         self.font_bold = pygame.font.SysFont("Arial", 14, bold=True)
+        self.font_small = pygame.font.SysFont("Arial", 11)
         self.font_icon = pygame.font.SysFont("Consolas", 20)
 
         self.search_input = InlineTextInput("search", "")
@@ -1606,13 +1607,21 @@ class FileManager:
             pygame.draw.rect(screen, COLORS["border"], bar_rect, border_radius=2)
 
     def _draw_footer(self, screen, rect):
-        sel_txt = "No file selected"
-        if self.selected_index != -1:
+        sel_txt: str
+        if self.multi_select and len(self.selected_indices) > 1:
+            sel_txt = f"{len(self.selected_indices)} files selected"
+        elif self.selected_index != -1:
             sel_txt = self.items[self.selected_index].name
+        else:
+            sel_txt = "No file selected"
 
-        txt_surf = self.font_main.render(sel_txt, True, COLORS["text_dim"])
         if self.mode == "open":
-            screen.blit(txt_surf, (rect.x + 10, rect.y + 17))
+            txt_surf = self.font_main.render(sel_txt, True, COLORS["text_dim"])
+            screen.blit(txt_surf, (rect.x + 10, rect.y + 12))
+            if self.multi_select:
+                hint = "[Ctrl+Click] toggle  [Shift+Click] range  [Open] confirm"
+                hint_surf = self.font_small.render(hint, True, COLORS["text_dim"])
+                screen.blit(hint_surf, (rect.x + 10, rect.y + 28))
 
         btn_w, btn_h = 80, 30
         margin = 10

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/src/widgets/tile_grid.py

@@ -1449,10 +1449,11 @@ class TileGrid:
 
         sel_rect = Rect(int(sx), int(sy), int(sw), int(sh))
 
-        # Semi-transparent fill
-        fill_surf = pygame.Surface((int(sw), int(sh)), pygame.SRCALPHA)
-        fill_surf.fill((100, 180, 255, 40))
-        screen.blit(fill_surf, (int(sx), int(sy)))
+        # Semi-transparent fill (skip during drag to avoid visual noise)
+        if not self.is_selecting:
+            fill_surf = pygame.Surface((int(sw), int(sh)), pygame.SRCALPHA)
+            fill_surf.fill((100, 180, 255, 40))
+            screen.blit(fill_surf, (int(sx), int(sy)))
 
         # Dashed border (draw segments)
         border_color = (100, 180, 255) if not self.is_moving else (255, 200, 50)

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/src/widgets/ui/menubar.py

@@ -76,6 +76,11 @@ class MenuBar:
                     MenuAction(
                         "Toggle Auto-Autotile", self.editor.toggle_auto_autotile
                     ),
+                    MenuAction(
+                        "Export Selection as PNG",
+                        self.editor.export_selection_as_png,
+                        "Ctrl+Shift+E",
+                    ),
                     MenuAction(
                         "Launch External Viewer", self.editor.launch_external_automap
                     ),

{tilemap_editor-3.2.10 → tilemap_editor-3.3.1}/src/widgets/ui/tileset_type_dialog.py

@@ -71,7 +71,7 @@ class TilesetTypeDialog:
         """Position child controls from the current dialog rect."""
         self.rect.center = self.editor_rect.center
 
-        h = 220
+        h = 260
         if self.animated or self._editing_field is not None:
             h = 420
         self.rect.h = h
@@ -97,7 +97,7 @@ class TilesetTypeDialog:
         )
 
         # Animated checkbox
-        anim_y = first_y + (row_h + gap) * 2 + 6
+        anim_y = first_y + (row_h + gap) * 2 + 16
         self.anim_check_rect = Rect(radio_x, anim_y, 16, 16)
 
         # Animation fields (collapsible)