tilemap-editor 3.2.1__tar.gz → 3.2.3__tar.gz

{tilemap_editor-3.2.1/src/tilemap_editor.egg-info → tilemap_editor-3.2.3}/PKG-INFO

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

{tilemap_editor-3.2.1 → tilemap_editor-3.2.3}/pyproject.toml

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

{tilemap_editor-3.2.1 → tilemap_editor-3.2.3}/src/editor.py

@@ -150,6 +150,9 @@ class Editor:
         self.running = False
         self.pan_mode = False
         self.autotile_mode = False
+        self.eraser_mode = False
+        self.select_mode = False
+        self._prev_tool = None
 
         if isinstance(size, tuple) and len(size) == 2:
             self.screen = pygame.display.set_mode(size, pygame.RESIZABLE)
@@ -684,13 +687,17 @@ class Editor:
         self.open_file_manager(
             on_select=self._launch_animation_editor_with_image,
             initial_dir=self.data_root,
-            allowed_exts=[".png", ".jpg", ".jpeg"],
+            allowed_exts=[".png", ".jpg", ".jpeg", ".json"],
             mode="open",
         )
 
     def _launch_animation_editor_with_image(self, path: Path):
-        """Launch animation editor subprocess with selected image."""
+        """Launch animation editor subprocess with selected image or JSON."""
         try:
+            if path.suffix.lower() == ".json":
+                self._launch_animation_editor_with_json(path)
+                return
+
             tile_size = "32x32"
             if hasattr(self.tilemap, "tile_size") and self.tilemap.tile_size:
                 tw, th = self.tilemap.tile_size
@@ -711,6 +718,47 @@ class Editor:
         except Exception as e:
             error_handler.capture(e, context="launch_animation_editor")
 
+    def _launch_animation_editor_with_json(self, path: Path) -> None:
+        """Launch animation editor from a saved .anim.json file."""
+        try:
+            from plugins.sprite_animation.models import AnimationLibrary
+            from utils.project_paths import resolve_project_path
+
+            lib = AnimationLibrary.load(path)
+            spritesheet_path = lib.spritesheet_path
+            tile_size = lib.tile_size
+
+            if spritesheet_path:
+                resolved = resolve_project_path(
+                    spritesheet_path,
+                    path.parent,
+                    fallback_roots=[self.base_path] if self.base_path else None,
+                    must_exist=True,
+                )
+            else:
+                resolved = None
+
+            if not resolved or not resolved.exists():
+                print(f"Could not locate spritesheet for animation file: {path.name}")
+                return
+
+            args = [
+                str(resolved),
+                "--tile-size", f"{tile_size[0]}x{tile_size[1]}",
+                "--load", str(path),
+                "--data-root", str(self.data_root),
+            ]
+            process = launch_standalone(
+                "plugins.sprite_animation.standalone",
+                args,
+                cwd=self.base_path,
+                text=True,
+            )
+            self.child_processes.append(process)
+            print(f"Launched animation editor with: {path.name} (spritesheet: {resolved.name})")
+        except Exception as e:
+            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(
@@ -1018,7 +1066,24 @@ class Editor:
                     self.perform_load()
                     continue
                 elif event.key == pygame.K_SPACE:
-                    self.pan_mode = not self.pan_mode
+                    if self.pan_mode:
+                        # Restoring: turn off pan, re-enable previous tool
+                        self.pan_mode = False
+                        if getattr(self, "_prev_tool", None) == "select":
+                            self.select_mode = True
+                        elif getattr(self, "_prev_tool", None) == "eraser":
+                            self.eraser_mode = True
+                    else:
+                        # Entering pan: save current tool, turn off others
+                        if self.select_mode:
+                            self._prev_tool = "select"
+                        elif self.eraser_mode:
+                            self._prev_tool = "eraser"
+                        else:
+                            self._prev_tool = None
+                        self.pan_mode = True
+                        self.select_mode = False
+                        self.eraser_mode = False
                     continue
                 elif event.mod & pygame.KMOD_CTRL and event.key == pygame.K_g:
                     self.toggle_grid()

{tilemap_editor-3.2.1 → tilemap_editor-3.2.3}/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.1 → tilemap_editor-3.2.3}/src/plugins/sprite_animation/editor.py

@@ -1367,7 +1367,7 @@ class SpriteAnimationEditor:
             self.preview.set_surface(self._surface, self._tile_size)
             self.timeline.surface = self._surface
             self.timeline.tile_size = self._tile_size
-            self.timeline._thumb_cache.clear()
+            self.timeline.invalidate_cache()
 
             # Update input fields to show clamped values
             self._frame_width_input = str(width)
@@ -1404,7 +1404,7 @@ class SpriteAnimationEditor:
             if hasattr(self.timeline, "grid_offset_x"):
                 self.timeline.grid_offset_x = offset_x
                 self.timeline.grid_offset_y = offset_y
-                self.timeline._thumb_cache.clear()
+                self.timeline.invalidate_cache()
 
             # Update preview with offset (if it has the attribute)
             if hasattr(self.preview, "grid_offset_x"):
@@ -1420,6 +1420,43 @@ class SpriteAnimationEditor:
             self._offset_x_input = str(self._grid_offset_x)
             self._offset_y_input = str(self._grid_offset_y)
 
+    def _apply_library_grid_settings(self) -> None:
+        """Sync tile_size and grid_offset from the loaded library to all widgets."""
+        tw, th = self.library.tile_size
+        self._tile_size = (tw, th)
+        self.library.tile_size = (tw, th)
+
+        # Update frame picker
+        self.frame_picker.set_surface(self._surface, self._tile_size)
+
+        # Update preview and timeline
+        self.preview.set_surface(self._surface, self._tile_size)
+        self.timeline.surface = self._surface
+        self.timeline.tile_size = self._tile_size
+        self.timeline.invalidate_cache()
+
+        # Update frame size input fields
+        self._frame_width_input = str(tw)
+        self._frame_height_input = str(th)
+
+        # Sync grid offset from library
+        gx, gy = self.library.grid_offset
+        self._grid_offset_x = gx
+        self._grid_offset_y = gy
+        self._offset_x_input = str(gx)
+        self._offset_y_input = str(gy)
+
+        # Propagate offset to all widgets
+        if hasattr(self.frame_picker, "set_grid_offset"):
+            self.frame_picker.set_grid_offset(gx, gy)
+        if hasattr(self.timeline, "grid_offset_x"):
+            self.timeline.grid_offset_x = gx
+            self.timeline.grid_offset_y = gy
+            self.timeline.invalidate_cache()
+        if hasattr(self.preview, "grid_offset_x"):
+            self.preview.grid_offset_x = gx
+            self.preview.grid_offset_y = gy
+
     def _sync_active_animation(self) -> None:
         """Push current animation data to sub-widgets."""
         anim = self._get_active()
@@ -1843,6 +1880,7 @@ class SpriteAnimationEditor:
             print(f"Warning: Could not import FileManager: {e}")
             path = self._default_save_path()
             try:
+                self.library.grid_offset = (self._grid_offset_x, self._grid_offset_y)
                 self.library.save(path, base_path=path.parent)
                 self._last_saved_path = path
                 print(f"Animations saved to {path}")
@@ -1888,6 +1926,7 @@ class SpriteAnimationEditor:
         if self._last_saved_path:
             # Save to existing path
             try:
+                self.library.grid_offset = (self._grid_offset_x, self._grid_offset_y)
                 self.library.save(
                     self._last_saved_path,
                     base_path=self._last_saved_path.parent,
@@ -1913,6 +1952,7 @@ class SpriteAnimationEditor:
                 try:
                     self.library = AnimationLibrary.load(path)
                     self._resolve_library_paths(path)
+                    self._apply_library_grid_settings()
                     names = self.library.animation_names()
                     self._active_anim_name = names[0] if names else None
                     if not names:
@@ -1948,6 +1988,8 @@ class SpriteAnimationEditor:
     def _on_save_file_selected(self, path: Path) -> None:
         """Callback when user selects a file to save to."""
         try:
+            # Sync current grid offset into library before saving
+            self.library.grid_offset = (self._grid_offset_x, self._grid_offset_y)
             self.library.save(path, base_path=path.parent)
             self._last_saved_path = path  # Track for quick save
             print(f"Animations saved to {path}")
@@ -1968,6 +2010,7 @@ class SpriteAnimationEditor:
                 self.library = AnimationLibrary.load(path)
                 self._resolve_library_paths(path)
                 self._last_saved_path = path  # Track loaded file as save location
+                self._apply_library_grid_settings()
                 names = self.library.animation_names()
                 self._active_anim_name = names[0] if names else None
                 if not names:
@@ -2110,6 +2153,7 @@ class SpriteAnimationEditor:
     def load_animation_data(self, data: dict) -> None:
         """Load animation library from a dict (e.g. from project JSON)."""
         self.library = AnimationLibrary.from_dict(data)
+        self._apply_library_grid_settings()
         names = self.library.animation_names()
         self._active_anim_name = names[0] if names else None
         if not names:

{tilemap_editor-3.2.1 → tilemap_editor-3.2.3}/src/plugins/sprite_animation/models.py

@@ -167,6 +167,7 @@ class AnimationLibrary:
     animations: Dict[str, Animation] = field(default_factory=dict)
     spritesheet_path: Optional[str] = None
     tile_size: Tuple[int, int] = (32, 32)
+    grid_offset: Tuple[int, int] = (0, 0)
 
     def add_animation(self, anim: Animation) -> None:
         self.animations[anim.name] = anim
@@ -199,6 +200,7 @@ class AnimationLibrary:
         return {
             "spritesheet_path": spritesheet_path,
             "tile_size": list(self.tile_size),
+            "grid_offset": list(self.grid_offset),
             "animations": {
                 name: anim.to_dict() for name, anim in self.animations.items()
             },
@@ -209,6 +211,7 @@ class AnimationLibrary:
         lib = AnimationLibrary(
             spritesheet_path=data.get("spritesheet_path"),
             tile_size=tuple(data.get("tile_size", [32, 32])),
+            grid_offset=tuple(data.get("grid_offset", [0, 0])),
         )
         for name, anim_data in data.get("animations", {}).items():
             lib.animations[name] = Animation.from_dict(anim_data)

{tilemap_editor-3.2.1 → tilemap_editor-3.2.3}/src/plugins/sprite_animation/timeline.py

@@ -140,6 +140,10 @@ class Timeline:
             self.tile_size = tile_size
         self._thumb_cache.clear()
 
+    def invalidate_cache(self) -> None:
+        """Clear the thumbnail cache. Call after external changes to surface, tile_size, or grid offset."""
+        self._thumb_cache.clear()
+
     def resize(self, rect: Rect) -> None:
         self.rect = rect
 

{tilemap_editor-3.2.1 → tilemap_editor-3.2.3/src/tilemap_editor.egg-info}/PKG-INFO

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