tilemap-editor 3.2.0__tar.gz → 3.2.2__tar.gz

{tilemap_editor-3.2.0/src/tilemap_editor.egg-info → tilemap_editor-3.2.2}/PKG-INFO

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

{tilemap_editor-3.2.0 → tilemap_editor-3.2.2}/pyproject.toml

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

{tilemap_editor-3.2.0 → tilemap_editor-3.2.2}/src/editor.py

@@ -723,7 +723,12 @@ class Editor:
     def _launch_sprite_editor_with_image(self, path: Path):
         """Launch sprite editor subprocess with selected image."""
         try:
-            args = [str(path), "--data-root", str(self.data_root)]
+            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)]
             process = launch_standalone(
                 "plugins.sprite_editor.standalone",
                 args,

{tilemap_editor-3.2.0 → tilemap_editor-3.2.2}/src/plugins/character_collision/editor.py

@@ -3,7 +3,7 @@ Character Collision Editor — Define collision shapes for character sprites.
 
 Layout:
     +----------------------------------------------------+
-    | Toolbar: [Character Name] [Shape Type Buttons]    |
+    | Toolbar: [Name: _______] [Shape Type Buttons]      |
     +----------------------------------------------------+
     |                                                    |
     |              Shape Editor                          |
@@ -16,6 +16,7 @@ Layout:
 
 from __future__ import annotations
 
+import re
 from typing import Optional, Tuple, Dict, Any
 from pathlib import Path
 
@@ -30,6 +31,7 @@ from utils.error_handler import error_handler, error_context
 from widgets.ui.theme import COLORS, FONTS
 from widgets.ui.draw_utils import draw_panel, draw_button
 from widgets.ui.collision_layer_sidebar import CollisionLayerSidebar
+from widgets.input import InlineTextInput
 
 
 class CharacterCollisionEditor:
@@ -73,6 +75,9 @@ class CharacterCollisionEditor:
         self._font = font_manager.get_font(FONTS.name, FONTS.size_md, FontWeight.REGULAR)
         self._font_sm = font_manager.get_font(FONTS.name, FONTS.size_sm, FontWeight.REGULAR)
 
+        # Editable name input
+        self._name_input = InlineTextInput("char_name", default_val=self.character_name)
+
         # Shape type buttons
         self.shape_buttons: Dict[ShapeType, Rect] = {}
         self._init_shape_buttons()
@@ -106,6 +111,18 @@ class CharacterCollisionEditor:
 
         self._init_shape_buttons()
 
+    def _get_save_name(self) -> str:
+        """Build filename from the name input.
+
+        Returns "<safe-name>-character.collision.json" if non-empty,
+        "character.collision.json" otherwise.
+        """
+        name = self._name_input.text.strip()
+        if name:
+            safe = re.sub(r'[^\w\-]+', '-', name).strip('-').lower()
+            return f"{safe}-character.collision.json"
+        return "character.collision.json"
+
     def get_collision_data(self) -> CharacterCollisionData:
         """Get the current collision data"""
         shape_data = self.shape_editor.get_shape_data()
@@ -145,7 +162,7 @@ class CharacterCollisionEditor:
             raise ValueError(f"Unknown shape type: {shape_type}")
 
         return CharacterCollisionData(
-            name=self.character_name,
+            name=self._name_input.text.strip() or self.character_name,
             shape=shape,
             properties={
                 "collision_layer": self.layer_sidebar.get_layer(),
@@ -156,12 +173,28 @@ class CharacterCollisionEditor:
     def load_collision_data(self, data: CharacterCollisionData) -> None:
         """Load collision data"""
         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)
         self.layer_sidebar.set_mask(mask)
 
+    def _get_save_path(self) -> Path:
+        """Full path for saving/loading collision data."""
+        collision_dir = self._get_collision_dir()
+        return collision_dir / self._get_save_name()
+
+    def _get_load_path(self) -> Path:
+        """Path to load from — name-priority, fallback to default."""
+        collision_dir = self._get_collision_dir()
+        name_path = collision_dir / self._get_save_name()
+        if name_path.exists():
+            return name_path
+        # Fallback to default
+        return collision_dir / "character.collision.json"
+
     def _get_collision_dir(self) -> Path:
         """Get collision data directory (data_root/character_collision)"""
         if self._data_root is None:
@@ -189,11 +222,17 @@ class CharacterCollisionEditor:
         except Exception as e:
             error_handler.capture(e, context="load_character_collision")
 
+    def _name_input_rect(self) -> Rect:
+        """Screen rect for the editable name field in the toolbar."""
+        return Rect(self.rect.x + 62, self.rect.y + 10, 175, 28)
+
     def handle_event(self, event: pygame.event.Event) -> bool:
         """Handle input events"""
         if not self.visible:
             return False
 
+        mouse = pygame.mouse.get_pos()
+
         # Layer/mask sidebar handles events when open
         if self.layer_sidebar.handle_event(event):
             return True
@@ -202,19 +241,40 @@ class CharacterCollisionEditor:
         if self.layer_sidebar.handle_toggle_event(event):
             return True
 
-        # Keyboard shortcut: L to toggle sidebar
-        if event.type == pygame.KEYDOWN and event.key == pygame.K_l:
+        # Keyboard shortcut: L to toggle sidebar (skip when name input is focused)
+        if event.type == pygame.KEYDOWN and event.key == pygame.K_l and not self._name_input.is_focused:
             mods = pygame.key.get_mods()
             if not (mods & (pygame.KMOD_CTRL | pygame.KMOD_LMETA)):
                 self.layer_sidebar.toggle()
                 return True
 
+        # Name input handling
+        if self._name_input.is_focused:
+            if event.type == pygame.KEYDOWN:
+                if event.key == pygame.K_RETURN:
+                    self._name_input.is_focused = False
+                    return True
+                elif event.key == pygame.K_ESCAPE:
+                    self._name_input.is_focused = False
+                    return True
+            if self._name_input.handle_event(event, self._font):
+                return True
+            # Tab/click outside handled below
+
+        # Click-to-focus name input
+        if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
+            if self._name_input_rect().collidepoint(mouse):
+                self._name_input.is_focused = True
+                self._name_input.cursor_pos = len(self._name_input.text)
+                self._name_input.selection_start = None
+                return True
+            elif self._name_input.is_focused:
+                self._name_input.is_focused = False
+
         # Let shape editor handle events next
         if self.shape_editor.handle_event(event):
             return True
 
-        mouse = pygame.mouse.get_pos()
-
         # Shape type button clicks
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
             for shape_type, button_rect in self.shape_buttons.items():
@@ -249,13 +309,30 @@ class CharacterCollisionEditor:
         toolbar_rect = Rect(self.rect.x, self.rect.y, self.rect.w, self.toolbar_height)
         draw_panel(screen, toolbar_rect, COLORS.header, COLORS.border)
 
-        # Title
-        title = self._font.render(
-            f"Character Collision Editor — {self.character_name}",
-            True,
-            COLORS.text
+        # "Name:" label
+        label = self._font_sm.render("Name:", True, COLORS.text)
+        screen.blit(label, (toolbar_rect.x + 10, toolbar_rect.y + 17))
+
+        # Editable name field
+        name_rect = self._name_input_rect()
+        bg_color = COLORS.panel if self._name_input.is_focused else COLORS.panel_alt
+        pygame.draw.rect(screen, bg_color, name_rect, border_radius=4)
+        pygame.draw.rect(
+            screen, COLORS.accent if self._name_input.is_focused else COLORS.border,
+            name_rect, 1, border_radius=4,
         )
-        screen.blit(title, (toolbar_rect.x + 10, toolbar_rect.y + 15))
+
+        # Render input text
+        display_name = self._name_input.text or "character"
+        txt = self._font_sm.render(display_name, True, COLORS.text)
+        screen.blit(txt, (name_rect.x + 4, name_rect.y + 5))
+
+        # Cursor when focused
+        if self._name_input.is_focused and (pygame.time.get_ticks() // 400) % 2:
+            pre = self._font_sm.render(self._name_input.text[:self._name_input.cursor_pos], True, (0, 0, 0))
+            cx = name_rect.x + 4 + pre.get_width()
+            cy = name_rect.y + 5
+            pygame.draw.line(screen, COLORS.text, (cx, cy), (cx, cy + txt.get_height()), 1)
 
         # Shape type buttons
         for shape_type, button_rect in self.shape_buttons.items():
@@ -352,15 +429,14 @@ class CharacterCollisionEditor:
                         # Ctrl+S / Cmd+S to save
                         collision_dir = self._get_collision_dir()
                         collision_dir.mkdir(parents=True, exist_ok=True)
-                        save_path = collision_dir / "character_collision.json"
+                        save_path = self._get_save_path()
                         self.save_to_file(save_path)
                         print(f"Saved collision data to {save_path}")
                     elif event.key == pygame.K_l and (
                         pygame.key.get_mods() & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
                     ):
                         # Ctrl+L / Cmd+L to load
-                        collision_dir = self._get_collision_dir()
-                        load_path = collision_dir / "character_collision.json"
+                        load_path = self._get_load_path()
                         if load_path.exists():
                             self.load_from_file(load_path)
                             print(f"Loaded collision data from {load_path}")

{tilemap_editor-3.2.0 → tilemap_editor-3.2.2/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.2.0 → tilemap_editor-3.2.2}/src/widgets/spritesheet_grid.py

@@ -318,27 +318,65 @@ class SpritesheetGrid:
         return result
 
     def paste_at(self, target_idx: int, tiles: Dict[int, Surface]) -> None:
-        """Write previously copied tiles starting at target grid position.
-        
-        Tiles are written in sorted source-index order, filling left-to-right
-        top-to-bottom from the target cell. Out-of-bounds writes are skipped.
+        """Write previously copied tiles preserving 2D layout.
+
+        Each source tile's row/col offset from the selection origin is
+        preserved at the target grid position. The canvas auto-expands
+        if pasted tiles exceed the current bounds.
         """
         if not tiles or target_idx < 0 or target_idx >= self.total_frames:
             return
+
+        src_origin_col = min(idx % self.cols for idx in tiles)
+        src_origin_row = min(idx // self.cols for idx in tiles)
+        target_col = target_idx % self.cols
+        target_row = target_idx // self.cols
+
+        # Pre-compute all destination positions using current grid dimensions
+        dst_positions: List[Tuple[int, int, Surface]] = []
+        for src_idx, tile in tiles.items():
+            src_c = src_idx % self.cols - src_origin_col
+            src_r = src_idx // self.cols - src_origin_row
+            dst_c = target_col + src_c
+            dst_r = target_row + src_r
+            dst_positions.append((dst_r, dst_c, tile))
+
+        # Expand canvas if needed
+        need_rows = max(r for r, _, _ in dst_positions) + 1
+        need_cols = max(c for _, c, _ in dst_positions) + 1
+        if need_rows > self.rows or need_cols > self.cols:
+            self._expand_canvas(max(self.cols, need_cols), max(self.rows, need_rows))
+
         self.snapshot()
-        sorted_src = sorted(tiles.keys())
-        for offset, src_idx in enumerate(sorted_src):
-            dst = target_idx + offset
-            if dst >= self.total_frames:
-                break
-            tile = tiles[src_idx]
+        for dst_row, dst_col, tile in dst_positions:
+            if dst_row >= self.rows or dst_col >= self.cols:
+                continue
+            dst = dst_row * self.cols + dst_col
             self.write_tile(dst, tile)
+
         # Select the newly pasted tiles
-        self.selected_indices = {
-            target_idx + offset
-            for offset in range(len(sorted_src))
-            if target_idx + offset < self.total_frames
-        }
+        self.selected_indices = set()
+        for dst_row, dst_col, _ in dst_positions:
+            if dst_row < self.rows and dst_col < self.cols:
+                self.selected_indices.add(dst_row * self.cols + dst_col)
+
+    def _expand_canvas(self, new_cols: int, new_rows: int) -> None:
+        """Enlarge the spritesheet surface to fit new_cols x new_rows tiles."""
+        tw, th = self.tile_size
+        new_w = new_cols * tw + self.grid_offset_x
+        new_h = new_rows * th + self.grid_offset_y
+        new_surf = Surface((new_w, new_h), SRCALPHA)
+        new_surf.fill((0, 0, 0, 0))
+        new_surf.blit(self.surface, (0, 0))
+        self.surface = new_surf
+        self.cols = new_cols
+        self.rows = new_rows
+        self.total_frames = new_cols * new_rows
+        # Reset view so the new area is visible
+        if self.offset_x < 0:
+            self.offset_x = 0
+        if self.offset_y < 0:
+            self.offset_y = 0
 
     def save_png(self, path: Path) -> None:
         """Write current surface to a PNG file."""