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

{tilemap_editor-3.2.1/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.1
+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.1 → tilemap_editor-3.2.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.2.1"
+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.1 → 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.1 → 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.1
+Version: 3.2.2
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary