tilemap-editor 2.0.8__tar.gz → 2.0.9__tar.gz

{tilemap_editor-2.0.8/src/tilemap_editor.egg-info → tilemap_editor-2.0.9}/PKG-INFO

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

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9}/pyproject.toml

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

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9}/src/editor.py

@@ -745,10 +745,11 @@ class Editor:
     def _launch_object_tileset_collision_editor_with_image(self, path: Path):
         """Launch object tileset collision editor (region-based)."""
         logger = self.logger if hasattr(self, 'logger') else None
-        args = [str(path), "--data-root", str(self.data_root)]
 
         collision_dir = self.data_root / self.config.get("collision_paths", {}).get("object_tileset", "collision")
         collision_path = collision_dir / f"{path.stem}.object_collision.json"
+
+        args = [str(path), "--data-root", str(self.data_root), "--collision-dir", str(collision_dir)]
         if collision_path.exists():
             args.extend(["--load", str(collision_path)])
 

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9}/src/plugins/object_tileset_collision/editor.py

@@ -81,6 +81,8 @@ class ObjectTilesetCollisionEditor:
         self._tileset_surface = tileset_surface
         self._tileset_name = "Object Tileset"
         self._data_root: Optional[Path] = None
+        self._collision_dir: Optional[Path] = None
+        self._tileset_path_stem: Optional[str] = None
 
         # Data model
         self.library = ObjectTilesetCollisionLibrary(tileset_name=self._tileset_name)
@@ -109,6 +111,10 @@ class ObjectTilesetCollisionEditor:
         self._help_scroll = 0
         self._help_content_height = 0
         
+        # Regions list state
+        self._regions_list_scroll = 0
+        self._regions_item_height = 50
+        
         # Fonts
         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)
@@ -423,7 +429,7 @@ class ObjectTilesetCollisionEditor:
 
     def _on_polygon_added(self, vertices: List[Tuple[float, float]]) -> None:
         """Called when a polygon is added to the painter"""
-        print(f"[POLYGON_ADDED] {len(vertices)} vertices")
+        error_handler.capture_info(f"Polygon added with {len(vertices)} vertices", context="object_collision_painter")
         self._save_current_collision_data()
         self._update_status()
 
@@ -439,13 +445,12 @@ class ObjectTilesetCollisionEditor:
     def _save_current_collision_data(self) -> None:
         """Save current painter polygons to library"""
         if not self._current_region_id:
-            print("[SAVE_CURRENT] No current region selected")
             return
         
         polygons = self.painter.get_polygons()
         one_way_flags = self.painter.get_one_way_flags()
         
-        print(f"[SAVE_CURRENT] Region {self._current_region_id}: {len(polygons)} polygons from painter")
+        error_handler.capture_info(f"Saving collision for region {self._current_region_id}: {len(polygons)} polygons", context="object_collision_save")
         
         shapes = [
             CollisionPolygon(vertices=poly, one_way=one_way)
@@ -454,7 +459,6 @@ class ObjectTilesetCollisionEditor:
         
         region = self._get_current_region()
         if not region:
-            print("[SAVE_CURRENT] Could not get current region")
             return
         
         if self._current_region_id in self.library.regions:
@@ -492,6 +496,14 @@ class ObjectTilesetCollisionEditor:
 
     # === Toolbar Actions ===
 
+    def _get_collision_dir(self) -> Path:
+        """Get the collision directory path."""
+        if self._collision_dir:
+            return self._collision_dir
+        if self._data_root:
+            return self._data_root / "collision"
+        raise RuntimeError("No collision directory configured. Set collision_dir or data_root.")
+
     def _save_collision(self) -> None:
         """Save collision data to file"""
         if not self._data_root:
@@ -499,19 +511,18 @@ class ObjectTilesetCollisionEditor:
             return
         
         try:
-            collision_dir = self._data_root / "collision"
+            collision_dir = self._get_collision_dir()
             collision_dir.mkdir(parents=True, exist_ok=True)
-            save_path = collision_dir / f"{self._tileset_name}.object_collision.json"
+            stem = getattr(self, '_tileset_path_stem', self._tileset_name)
+            save_path = collision_dir / f"{stem}.object_collision.json"
             
             # Sync current painter data
             if self._mode == EditorMode.PAINT_COLLISION:
                 self._save_current_collision_data()
             
-            # Debug: Print what we're saving
+            # Log what we're saving
             total_shapes = sum(len(data.shapes) for data in self.library.regions.values())
-            print(f"[SAVE] Saving {len(self.library.regions)} regions with {total_shapes} total shapes to {save_path}")
-            for region_id, data in self.library.regions.items():
-                print(f"  - {region_id} ({data.name}): {len(data.shapes)} shapes")
+            error_handler.capture_info(f"Saving {len(self.library.regions)} regions with {total_shapes} total shapes to {save_path}", context="object_collision_save")
             
             self.library.save(save_path)
             self.status_bar.success("Saved", f"{save_path.name}")
@@ -519,7 +530,6 @@ class ObjectTilesetCollisionEditor:
         except Exception as e:
             self.status_bar.error("Save failed", str(e))
             error_handler.capture(e, context="object_collision_editor_save")
-            print(f"[SAVE ERROR] {e}")
 
     def load_from_file(self, path: Path) -> None:
         """Load collision data from a specific file path"""
@@ -559,8 +569,9 @@ class ObjectTilesetCollisionEditor:
             self.status_bar.error("Cannot load", "No data root specified")
             return
         
-        collision_dir = self._data_root / "collision"
-        load_path = collision_dir / f"{self._tileset_name}.object_collision.json"
+        collision_dir = self._get_collision_dir()
+        stem = getattr(self, '_tileset_path_stem', self._tileset_name)
+        load_path = collision_dir / f"{stem}.object_collision.json"
         self.load_from_file(load_path)
 
     def _toggle_help(self) -> None:
@@ -593,7 +604,7 @@ class ObjectTilesetCollisionEditor:
         pygame.draw.rect(screen, COLORS.border, panel_rect, 2, border_radius=SHAPE.radius)
         
         # Title
-        title = self._font.render("Object Collision Editor Help", True, COLORS.text)
+        title = self._font.render("Object Tileset Collision Editor Help", True, COLORS.text)
         screen.blit(title, (panel_x + 15, panel_y + 15))
         
         # Close button
@@ -773,11 +784,11 @@ class ObjectTilesetCollisionEditor:
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
             mouse = pygame.mouse.get_pos()
             if self.regions_list_rect.collidepoint(mouse):
-                # Calculate which region was clicked
-                list_y = mouse[1] - (self.regions_list_rect.y + 35)
-                item_height = 50
-                if list_y >= 0:
-                    idx = list_y // item_height
+                # Calculate which region was clicked (accounting for scroll)
+                rel_y = mouse[1] - (self.regions_list_rect.y + 35 - self._regions_list_scroll)
+                item_height = self._regions_item_height
+                if rel_y >= 0:
+                    idx = int(rel_y) // item_height
                     if idx < len(self.region_selector.regions):
                         region = self.region_selector.regions[idx]
                         # Check if clicking same region (might be renaming)
@@ -812,6 +823,15 @@ class ObjectTilesetCollisionEditor:
                 self._toggle_help()
                 return True
         
+        # Mouse wheel scrolling for regions list
+        if event.type == pygame.MOUSEWHEEL:
+            mouse = pygame.mouse.get_pos()
+            if self.regions_list_rect.collidepoint(mouse):
+                self._regions_list_scroll -= event.y * 30
+                max_scroll = max(0, len(self.region_selector.regions) * self._regions_item_height - (self.regions_list_rect.height - 35))
+                self._regions_list_scroll = max(0, min(self._regions_list_scroll, max_scroll))
+                return True
+
         # Keyboard shortcuts
         if event.type == pygame.KEYDOWN:
             mods = pygame.key.get_mods()
@@ -901,14 +921,21 @@ class ObjectTilesetCollisionEditor:
         header = self._font.render("Regions", True, COLORS.text)
         screen.blit(header, (self.regions_list_rect.x + 10, self.regions_list_rect.y + 10))
         
-        # List regions
-        y = self.regions_list_rect.y + 35
-        item_height = 50
+        # List regions (with scroll offset)
+        y = self.regions_list_rect.y + 35 - self._regions_list_scroll
+        item_height = self._regions_item_height
         
         clip = screen.get_clip()
         screen.set_clip(self.regions_list_rect)
         
         for region in self.region_selector.regions:
+            # Skip items outside visible area
+            if y + item_height < self.regions_list_rect.y:
+                y += item_height
+                continue
+            if y > self.regions_list_rect.bottom:
+                break
+
             is_selected = region.id == self._current_region_id
             is_renaming = region.id == self._renaming_region_id
             
@@ -1015,12 +1042,15 @@ class ObjectTilesetCollisionEditor:
         tileset_path: Path,
         window_size: Tuple[int, int] = (1200, 800),
         data_root: Path = None,
+        collision_dir: Path = None,
     ) -> "ObjectTilesetCollisionEditor":
         """Create editor from tileset image path"""
         surface = pygame.image.load(tileset_path).convert_alpha()
         rect = Rect(0, 0, window_size[0], window_size[1])
         editor = cls(rect, surface)
         editor._data_root = data_root
+        editor._collision_dir = collision_dir
+        editor._tileset_path_stem = tileset_path.stem
         editor._tileset_name = tileset_path.stem
         editor.library.tileset_name = tileset_path.stem
         return editor

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9}/src/plugins/object_tileset_collision/standalone.py

@@ -34,6 +34,7 @@ def main(argv: list[str] | None = None) -> None:
         parser.add_argument("image", type=Path, help="Path to object tileset image")
         parser.add_argument("--window-size", type=str, default="1200x800", help="Window size WxH")
         parser.add_argument("--data-root", type=Path, required=True, help="Data root path")
+        parser.add_argument("--collision-dir", type=Path, default=None, help="Collision directory override")
         parser.add_argument("--load", type=Path, default=None, help="Load existing collision file")
 
         args = parser.parse_args(argv)
@@ -48,10 +49,13 @@ def main(argv: list[str] | None = None) -> None:
         screen = pygame.display.set_mode(window_size, pygame.RESIZABLE)
         pygame.display.set_caption(f"Object Tileset Collision — {args.image.name}")
 
+        collision_dir = args.collision_dir
+
         editor = ObjectTilesetCollisionEditor.from_path(
             args.image,
             window_size=window_size,
             data_root=args.data_root,
+            collision_dir=collision_dir,
         )
 
         if args.load and args.load.exists():

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9}/src/plugins/tileset_collision/editor.py

@@ -144,7 +144,6 @@ class TilesetCollisionEditor:
         collision_dir.mkdir(parents=True, exist_ok=True)
         stem = getattr(self, '_tileset_path_stem', self._tileset_name)
         save_path = collision_dir / f"{stem}.collision.json"
-        print(f"[SAVE] Saving to: {save_path}")
         self.save_to_file(save_path)
 
     def _load_collision(self) -> None:
@@ -152,12 +151,8 @@ class TilesetCollisionEditor:
         collision_dir = self._get_collision_dir()
         stem = getattr(self, '_tileset_path_stem', self._tileset_name)
         load_path = collision_dir / f"{stem}.collision.json"
-        print(f"[LOAD] Trying: {load_path}, exists={load_path.exists()}")
         if load_path.exists():
             self.load_from_file(load_path)
-            print(f"[LOAD] Loaded: {load_path}")
-        else:
-            print(f"[LOAD] File not found")
 
     def _get_collision_dir(self) -> Path:
         """Get collision directory path"""
@@ -787,8 +782,8 @@ class TilesetCollisionEditor:
                     elif event.key == pygame.K_l and (
                         pygame.key.get_mods() & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
                     ):
-                        # Ctrl+L / Cmd+L to load
-                        load_path = Path("collision_data.json")
+                        collision_dir = self._get_collision_dir()
+                        load_path = collision_dir / f"{getattr(self, '_tileset_path_stem', self._tileset_name)}.collision.json"
                         if load_path.exists():
                             self.load_from_file(load_path)
                             print(f"Loaded collision data from {load_path}")

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9}/src/standalone_error_console.py

@@ -53,6 +53,8 @@ PALETTE_DARK = {
     "info_bg": (20, 30, 60),
     "dot_live": (35, 209, 96),
     "scrollbar_thumb": (80, 80, 80),
+    "danger": (248, 81, 73),
+    "danger_bg": (62, 20, 20),
 }
 
 C = PALETTE_DARK
@@ -229,7 +231,10 @@ class StandaloneErrorConsole:
             bx += bw + 8
 
         # Clear Button
-        self._clear_btn = Rect(w - 90, self.TITLEBAR_H + 10, 75, 26)
+        self._clear_btn = Rect(w - 175, self.TITLEBAR_H + 10, 75, 26)
+
+        # Delete Logs Button
+        self._delete_logs_btn = Rect(w - 90, self.TITLEBAR_H + 10, 75, 26)
 
         # Content Area
         content_top = self.TITLEBAR_H + self.TOOLBAR_H
@@ -258,6 +263,21 @@ class StandaloneErrorConsole:
             error_handler.capture(e, severity="error")
         self._refresh_entries()
 
+    def _purge_logs(self) -> None:
+        """Permanently purge the log file (truncate to empty)."""
+        try:
+            if self.log_file and self.log_file.exists():
+                with open(self.log_file, "w", encoding="utf-8") as f:
+                    pass
+                self.last_file_size = 0
+            self._all_entries = []
+            self._visible_entries = []
+            self._expanded_ids = set()
+            self._scroll_offset = 0
+            self._refresh_entries()
+        except Exception as e:
+            error_handler.capture(e, context="error_console_purge_logs")
+
     def _monitor_file(self):
         while self.running:
             try:
@@ -285,7 +305,7 @@ class StandaloneErrorConsole:
 
     def _get_entry_layout(self, entry: Dict, width: int) -> Dict[str, Any]:
         """Calculates dynamic height and text wrapping for a specific entry."""
-        wrap_w = width - 200  # Space for timestamp and tags
+        wrap_w = width - 245  # Space for timestamp (YYYY-MM-DD HH:MM:SS) + tag + padding
         msg_text = entry.get("message", "No message")
         ctx_text = entry.get("context", "")
 
@@ -368,6 +388,10 @@ class StandaloneErrorConsole:
                     self._all_entries = []
                     self._refresh_entries()
 
+                # Handle Delete Logs
+                if self._delete_logs_btn.collidepoint(event.pos):
+                    self._purge_logs()
+
                 # Handle Entry Expansion
                 if self.content_rect.collidepoint(event.pos):
                     rel_y = event.pos[1] - self.content_rect.y + self._scroll_offset
@@ -518,14 +542,15 @@ class StandaloneErrorConsole:
                 sev_icon = icon_manager.get_icon(icon_name, 14, icon_color)
                 self.screen.blit(sev_icon, (8, curr_y + self.CELL_PADDING))
 
-                # 1. Timestamp
-                ts = entry.get("timestamp", "")[11:19]
+                # 1. Timestamp (full ISO: YYYY-MM-DD HH:MM:SS)
+                raw_ts = entry.get("timestamp", "")
+                ts = raw_ts[:10].replace("T", " ") + " " + raw_ts[11:19] if raw_ts else ""
                 ts_surf = self.f_small.render(ts, True, C["text_tertiary"])
-                self.screen.blit(ts_surf, (15, curr_y + self.CELL_PADDING))
+                self.screen.blit(ts_surf, (12, curr_y + self.CELL_PADDING))
 
                 # 2. Tag
                 tag_col = C[f"{sev}_stripe"]
-                tag_rect = Rect(85, curr_y + self.CELL_PADDING - 2, 65, 18)
+                tag_rect = Rect(165, curr_y + self.CELL_PADDING - 2, 65, 18)
                 pygame.draw.rect(self.screen, tag_col, tag_rect, 1, border_radius=3)
                 tag_txt = self.f_small.render(sev.upper(), True, tag_col)
                 self.screen.blit(
@@ -537,7 +562,7 @@ class StandaloneErrorConsole:
                 )
 
                 # 3. Message (Wrapped)
-                text_x = 165
+                text_x = 245
                 text_y = curr_y + self.CELL_PADDING
                 for i, line in enumerate(layout["msg_lines"]):
                     m_surf = self.f_main.render(line, True, C["text_primary"])
@@ -701,6 +726,21 @@ class StandaloneErrorConsole:
             ),
         )
 
+        # Delete Logs
+        is_hover_delete = self._delete_logs_btn.collidepoint(self.mouse_pos)
+        delete_bg = C["danger_bg"] if is_hover_delete else C["bg_secondary"]
+        pygame.draw.rect(
+            self.screen, delete_bg, self._delete_logs_btn, border_radius=4
+        )
+        dtxt = self.f_small.render("Delete Logs", True, C["danger"])
+        self.screen.blit(
+            dtxt,
+            (
+                self._delete_logs_btn.centerx - dtxt.get_width() // 2,
+                self._delete_logs_btn.centery - dtxt.get_height() // 2,
+            ),
+        )
+
         # 3. Status Bar
         pygame.draw.rect(
             self.screen,

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9}/src/utils/error_handler.py

@@ -12,7 +12,7 @@ import json
 import traceback
 from datetime import datetime
 from pathlib import Path
-from typing import List, Dict, Any
+from typing import List, Dict, Any, Optional
 from contextlib import contextmanager
 
 
@@ -90,10 +90,10 @@ class ErrorHandler:
             message: The info message to log
             context: Context string describing where message originated
         """
-        self._capture_impl(ValueError(message), context, "info")
+        self._capture_impl(None, context, "info", message=message)
 
     def _capture_impl(
-        self, error: Exception, context: str = "", severity: str = "error"
+        self, error: Optional[Exception], context: str = "", severity: str = "error", message: Optional[str] = None
     ) -> None:
         """
         Internal implementation of error capture.
@@ -104,11 +104,11 @@ class ErrorHandler:
 
         error_data = {
             "timestamp": datetime.utcnow().isoformat() + "Z",
-            "error_type": type(error).__name__,
-            "message": str(error),
+            "error_type": type(error).__name__ if error else severity,
+            "message": str(error) if error else (message or ""),
             "context": context,
             "severity": severity,
-            "stack_trace": traceback.format_exc(),
+            "stack_trace": "".join(traceback.format_exception(type(error), error, error.__traceback__)) if error else None,
             "thread_id": threading.current_thread().ident,
         }
 

{tilemap_editor-2.0.8 → tilemap_editor-2.0.9}/src/widgets/ui/region_selector.py

@@ -636,7 +636,7 @@ class RegionSelector:
     def set_regions(self, regions: List[Region]) -> None:
         """Set all regions at once"""
         self.regions = regions
-        self.selected_id = None
+        self.select_region(None)
     
     def get_regions(self) -> List[Region]:
         """Get all regions"""