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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 2.0.6
+Version: 2.0.8
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary
@@ -12,6 +12,8 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pygame-ce>=2.5
+Requires-Dist: numpy>=1.0
+Requires-Dist: Pillow>=10.0
 Dynamic: license-file
 
 # tilemap-editor

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "2.0.6"
+version = "2.0.8"
 description = "Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -12,6 +12,8 @@ license = { text = "Proprietary" }
 authors = [{ name = "tilemap editor contributors" }]
 dependencies = [
   "pygame-ce>=2.5",
+  "numpy>=1.0",
+  "Pillow>=10.0",
 ]
 classifiers = [
   "Programming Language :: Python :: 3",

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

@@ -70,12 +70,77 @@ def setup_error_logging():
 logger = setup_error_logging()
 
 
+def _load_project_config() -> tuple[Path, Path, dict]:
+    """Load and validate settings.json from current working directory.
+
+    Returns:
+        Tuple of (base_path, data_root, config)
+
+    Raises:
+        RuntimeError: If settings.json is invalid or missing
+    """
+    settings_file = Path.cwd() / "settings.json"
+
+    if not settings_file.exists():
+        raise RuntimeError(
+            "settings.json not found. Run 'tilemap-editor init' first."
+        )
+
+    try:
+        with open(settings_file, "r", encoding="utf-8") as f:
+            config = json.load(f)
+    except json.JSONDecodeError as e:
+        raise RuntimeError(f"Invalid settings.json: {e}")
+
+    # Validate required fields
+    required_fields = ["base_path", "data_path", "error_handler"]
+    for field in required_fields:
+        if field not in config:
+            raise RuntimeError(f"Invalid settings.json: missing '{field}'")
+
+    base_path = Path(config["base_path"]).expanduser()
+
+    if not base_path.is_absolute():
+        raise RuntimeError("base_path must be absolute")
+
+    base_path = base_path.resolve()
+
+    venv_path = Path(sys.prefix).resolve()
+    if venv_path in base_path.parents:
+        raise RuntimeError("base_path cannot be inside virtual environment")
+
+    # Validate data_path is relative, not absolute
+    data_path = config["data_path"]
+    if Path(data_path).is_absolute():
+        raise RuntimeError("data_path must be relative, not absolute")
+
+    data_root = base_path / data_path
+
+    if not data_root.exists():
+        raise RuntimeError(f"Data directory not found: {data_root}. Run 'tilemap-editor init' to create project structure.")
+
+    # Initialize error_handler with proper paths
+    log_root = data_root / "logs"
+
+    # Create logs directory only, don't create data root
+    log_root.mkdir(parents=True, exist_ok=True)
+
+    from utils.error_handler import init_error_handler
+    init_error_handler(log_root=log_root, config=config["error_handler"])
+
+    return base_path, data_root, config
+
+
 # Backwards-compatible alias for existing editor.py call sites
 _launch_standalone_module = launch_standalone
 
 
 class Editor:
     def __init__(self, size: Optional[Tuple[int, int]] = None, fps=60):
+        self.base_path, self.data_root, self.config = _load_project_config()
+        logger.info(f"Project base_path: {self.base_path}")
+        logger.info(f"Data root: {self.data_root}")
+
         pygame.init()
         pygame.display.set_caption("Pure Pygame Editor")
 
@@ -189,13 +254,12 @@ class Editor:
 
         if initial_dir:
             try:
-                rel_path = initial_dir.relative_to(BASE_PATH)
+                rel_path = initial_dir.relative_to(self.base_path)
                 args.extend(["--initial-dir", str(rel_path)])
             except ValueError:
-                # Not relative to BASE_PATH, use absolute
                 args.extend(["--initial-dir", str(initial_dir)])
         else:
-            args.extend(["--initial-dir", "data"])
+            args.extend(["--initial-dir", str(self.base_path / "data")])
 
         # Add allowed extensions
         if allowed_exts:
@@ -214,7 +278,7 @@ class Editor:
             self.file_manager_process = launch_standalone(
                 "standalone_filemanager",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
 
@@ -328,7 +392,7 @@ class Editor:
         if self.tilemap.active_project_path:
             default_name = self.tilemap.active_project_path.name
         self.open_file_manager(
-            initial_dir=BASE_PATH / "data",
+            initial_dir=self.base_path / "data",
             allowed_exts=[".json"],
             mode="save",
             default_name=default_name,
@@ -350,7 +414,7 @@ class Editor:
     def perform_load(self):
         self.open_file_manager(
             on_select=self.on_map_file_selected,
-            initial_dir=BASE_PATH / "data",
+            initial_dir=self.base_path / "data",
             allowed_exts=[".json"],
         )
 
@@ -596,7 +660,7 @@ class Editor:
 
         self.open_file_manager(
             on_select=self._launch_animation_editor_with_image,
-            initial_dir=BASE_PATH / "data",
+            initial_dir=self.base_path / "data",
             allowed_exts=[".png", ".jpg", ".jpeg"],
             mode="open",
         )
@@ -609,11 +673,11 @@ class Editor:
                 tw, th = self.tilemap.tile_size
                 tile_size = f"{tw}x{th}"
 
-            args = [str(path), "--tile-size", tile_size]
+            args = [str(path), "--tile-size", tile_size, "--data-root", str(self.data_root)]
             process = launch_standalone(
                 "plugins.sprite_animation.standalone",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
             self.child_processes.append(process)
@@ -624,48 +688,83 @@ class Editor:
         except Exception as e:
             error_handler.capture(e, context="launch_animation_editor")
 
-    def launch_collision_editor(self):
-        """Launch the tileset collision editor in a new window.
+    def launch_collision_editor(self, tileset_type: str = "tile"):
+        """Launch the collision editor in a new window.
 
         Uses the active tileset image when one is loaded. If no tileset is
         selected, shows a notification.
+
+        Args:
+            tileset_type: "tile" for tileset collision editor, "object" for object tileset collision editor
         """
         sheet = self._active_tileset_image_path()
         if sheet is not None:
-            self._launch_collision_editor_with_image(sheet)
+            self._launch_collision_editor_with_image(sheet, tileset_type)
             return
 
         self.notifications.notify("No tileset loaded. Please load a tileset first.")
 
-    def _launch_collision_editor_with_image(self, path: Path):
+    def _launch_collision_editor_with_image(self, path: Path, tileset_type: str = "tile"):
         """Launch collision editor subprocess with selected tileset."""
         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]
-            
-            # Check if collision data file exists and load it
-            collision_path = path.with_suffix('.collision.json')
-            if collision_path.exists():
-                args.extend(["--load", str(collision_path)])
-
-            process = launch_standalone(
-                "plugins.tileset_collision.standalone",
-                args,
-                cwd=BASE_PATH,
-                text=True,
-            )
-            self.child_processes.append(process)
-
-            print(
-                f"Launched collision editor with: {path.name} (tile size: {tile_size})"
-            )
+            if tileset_type == "object":
+                self._launch_object_tileset_collision_editor_with_image(path)
+            else:
+                self._launch_tileset_collision_editor_with_image(path)
         except Exception as e:
             error_handler.capture(e, context="launch_collision_editor")
 
+    def _launch_tileset_collision_editor_with_image(self, path: Path):
+        """Launch tileset collision editor (tile-based)."""
+        logger = self.logger if hasattr(self, 'logger') else None
+        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)]
+
+        collision_dir = self.data_root / self.config.get("collision_paths", {}).get("tileset", "collision")
+        collision_path = collision_dir / f"{path.stem}.collision.json"
+        if collision_path.exists():
+            args.extend(["--load", str(collision_path)])
+
+        process = launch_standalone(
+            "plugins.tileset_collision.standalone",
+            args,
+            cwd=self.base_path,
+            text=True,
+        )
+        self.child_processes.append(process)
+
+        msg = f"[COLLISION] Launched tileset collision editor for: {path.name} (tile size: {tile_size}) | Save path: {collision_path}"
+        print(msg)
+        if logger:
+            logger.info(msg)
+
+    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"
+        if collision_path.exists():
+            args.extend(["--load", str(collision_path)])
+
+        process = launch_standalone(
+            "plugins.object_tileset_collision.standalone",
+            args,
+            cwd=self.base_path,
+            text=True,
+        )
+        self.child_processes.append(process)
+
+        msg = f"[COLLISION] Launched object tileset collision editor for: {path.name} | Save path: {collision_path}"
+        print(msg)
+        if logger:
+            logger.info(msg)
+
     def launch_character_collision_editor(self):
         """Launch the character collision editor in a new window.
 
@@ -673,7 +772,7 @@ class Editor:
         """
         self.open_file_manager(
             on_select=self._launch_character_collision_editor_with_image,
-            initial_dir=BASE_PATH / "data",
+            initial_dir=self.base_path / "data",
             allowed_exts=[".png", ".jpg", ".jpeg"],
             mode="open",
         )
@@ -684,17 +783,18 @@ class Editor:
             # Use filename (without extension) as default character name
             character_name = path.stem
 
-            args = [str(path), "--name", character_name]
+            args = [str(path), "--name", character_name, "--data-root", str(self.data_root)]
             
             # Check if collision data file exists and load it
-            collision_path = path.with_suffix('.collision.json')
+            collision_dir = self.data_root / self.config.get("collision_paths", {}).get("character", "character_collision")
+            collision_path = collision_dir / f"{character_name}.collision.json"
             if collision_path.exists():
                 args.extend(["--load", str(collision_path)])
 
             process = launch_standalone(
                 "plugins.character_collision.standalone",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
             self.child_processes.append(process)
@@ -721,11 +821,12 @@ class Editor:
 
             window_size = f"{console_width}x{console_height}"
 
-            args = ["--window-size", window_size]
+            log_file = self.data_root / "logs" / "errors.log"
+            args = ["--window-size", window_size, "--log-file", str(log_file)]
             process = launch_standalone(
                 "standalone_error_console",
                 args,
-                cwd=BASE_PATH,
+                cwd=self.base_path,
                 text=True,
             )
             self.child_processes.append(process)
@@ -767,6 +868,17 @@ class Editor:
 
     def _cleanup_finished_processes(self):
         """Remove finished processes from the tracking list."""
+        # Read output from finished processes
+        for process in self.child_processes:
+            if process.poll() is not None:
+                try:
+                    stdout, stderr = process.communicate(timeout=1)
+                    if stdout:
+                        print(f"[SUBPROCESS OUTPUT] {stdout}")
+                    if stderr:
+                        print(f"[SUBPROCESS ERROR] {stderr}")
+                except Exception:
+                    pass
         self.child_processes = [p for p in self.child_processes if p.poll() is None]
 
     def handle_events(self):
@@ -1023,10 +1135,6 @@ if __name__ == "__main__":
     sys.excepthook = handle_exception
 
     try:
-        log_path = setup_console_log(BASE_PATH)
-        if log_path:
-            print(f"Logging to {log_path}")
-
         with error_context("editor_main"):
             editor = Editor(size=(1500, 900))
             editor.run()

{tilemap_editor-2.0.6 → tilemap_editor-2.0.8}/src/plugins/character_collision/editor.py

@@ -43,6 +43,7 @@ class CharacterCollisionEditor:
         self.rect = rect
         self.sprite_surface = sprite_surface
         self.character_name = character_name
+        self._data_root: Path = None
         self.visible = True
 
         # UI layout
@@ -142,6 +143,12 @@ class CharacterCollisionEditor:
         self.character_name = data.name
         self.shape_editor.load_shape_data(data.shape.to_dict())
 
+    def _get_collision_dir(self) -> Path:
+        """Get collision data directory (data_root/character_collision)"""
+        if self._data_root is None:
+            raise RuntimeError("data_root is required. Initialize via from_path() with data_root parameter.")
+        return self._data_root / "character_collision"
+
     def save_to_file(self, path: Path) -> None:
         """Save collision data to file"""
         try:
@@ -274,11 +281,14 @@ class CharacterCollisionEditor:
         sprite_path: Path,
         window_size: Tuple[int, int] = (1000, 800),
         character_name: str = "Character",
+        data_root: Path = None,
     ) -> "CharacterCollisionEditor":
         """Create editor from sprite image path (for standalone use)"""
         surface = pygame.image.load(sprite_path).convert_alpha()
         rect = Rect(0, 0, window_size[0], window_size[1])
-        return cls(rect, surface, character_name)
+        editor = cls(rect, surface, character_name)
+        editor._data_root = data_root
+        return editor
 
     def run(self) -> None:
         """Run standalone editor (for standalone use)"""
@@ -300,14 +310,17 @@ class CharacterCollisionEditor:
                         pygame.key.get_mods() & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
                     ):
                         # Ctrl+S / Cmd+S to save
-                        save_path = Path("character_collision.json")
+                        collision_dir = self._get_collision_dir()
+                        collision_dir.mkdir(parents=True, exist_ok=True)
+                        save_path = collision_dir / "character_collision.json"
                         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
-                        load_path = Path("character_collision.json")
+                        collision_dir = self._get_collision_dir()
+                        load_path = collision_dir / "character_collision.json"
                         if load_path.exists():
                             self.load_from_file(load_path)
                             print(f"Loaded collision data from {load_path}")

{tilemap_editor-2.0.6 → tilemap_editor-2.0.8}/src/plugins/character_collision/standalone.py

@@ -72,9 +72,17 @@ def main(argv: list[str] | None = None) -> None:
             default="1000x800",
             help="Window size as WxH (default: 1000x800)",
         )
+        parser.add_argument(
+            "--data-root",
+            type=Path,
+            required=True,
+            help="Path to project data root directory (REQUIRED)",
+        )
 
         args = parser.parse_args(argv)
 
+        data_root = args.data_root
+
         if not args.image.exists():
             error_handler.capture(
                 Exception(f"File not found: {args.image}"),
@@ -94,6 +102,7 @@ def main(argv: list[str] | None = None) -> None:
                 args.image,
                 window_size=window_size,
                 character_name=args.name,
+                data_root=data_root,
             )
 
             if args.load and args.load.exists():

tilemap_editor-2.0.8/src/plugins/object_tileset_collision/__init__.py

@@ -0,0 +1,16 @@
+"""
+Object Tileset Collision Editor — Collision shape editor for object tilesets.
+
+This editor allows drawing collision polygons on object tilesets by defining
+manual regions within the sprite sheet, where each region can have its own
+collision shapes.
+"""
+
+from .editor import ObjectTilesetCollisionEditor
+from .models import RegionCollisionData, ObjectTilesetCollisionLibrary
+
+__all__ = [
+    "ObjectTilesetCollisionEditor",
+    "RegionCollisionData",
+    "ObjectTilesetCollisionLibrary",
+]