tilemap-editor 2.0.0__tar.gz → 2.0.2__tar.gz

{tilemap_editor-2.0.0 → tilemap_editor-2.0.2}/CHANGELOG.md

@@ -5,6 +5,25 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [2.0.1] - 2025-04-23
+
+### Added
+- **Tileset Collision Plugin**: Godot-like polygon collision editor
+  - `CollisionPainter`: Interactive polygon drawing with edge-constrain mode
+  - `TilesetCollisionEditor`: Full editor with tile selector and painted tiles list
+  - `TilesetCollisionLibrary`: Persistent collision data management
+  - Edge-draw mode (`E` key + `Shift`) for precise slope/stair creation
+  - Help panel (`H` key) with all controls documented
+  - One-way collision support for platforms
+  - Zoom, pan, and grid controls
+- **Character Collision Plugin**: Shape-based character collision editor
+  - Rectangle, Circle, and Capsule shape support
+  - Protocol-based design for easy integration
+
+### Changed
+- Updated pyproject.toml version to 2.0.1
+- Improved editor.py and tile_selector.py integration
+
 ## [2.0.0] - 2025-04-22
 
 ### Major Changes

{tilemap_editor-2.0.0/src/tilemap_editor.egg-info → tilemap_editor-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-editor
-Version: 2.0.0
+Version: 2.0.2
 Summary: Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools
 Author: tilemap editor contributors
 License: Proprietary
@@ -16,25 +16,29 @@ Dynamic: license-file
 
 # tilemap-editor
 
+> [!WARNING]
+> This is mostly vibe coded as working with ui isnt so easy in pygame. Somehow it works for me. Though it took decent time as this was initially too buggy(which still is as expected). Just an experiment and keep customizing for my need.
+PRs are welcome.
+
 `tilemap-editor` is a pygame-based map editor focused on fast iteration for 2D games.
+`tilemap-parser` to parse this editor. (https://pypi.org/project/tilemap-parser/)[https://pypi.org/project/tilemap-parser/]
 
 ## What it includes
 
 - **Multi-layer tile/object map editing** with visual layer management
-- **Professional UI** with SVG icons, consistent fonts, and modern design
+- **Decent enough UI** with SVG icons, consistent fonts, and modern design
 - **Sprite animation editor** (`tilemap-anim-editor`) with frame-by-frame editing
 - **Built-in tools**: File manager, error console, image viewer, automapper
 - **Font management** with auto-selected coding fonts for clarity
 - **Icon system** with 26+ SVG icons and geometric fallbacks
 - **JSON save/load** compatible with this editor
+- **Decent console** toggled with ctrl + ` for error/warning/logs/debugging
 
 ## Key Features
 
 ### UI Improvements
-- Crisp SVG icons throughout the interface
+- SVG icons throughout the interface
 - Bold, auto-selected coding fonts (JetBrains Mono, Fira Code, Consolas)
-- Professional color scheme and consistent styling
-- Dynamic icon loading - icons auto-load by button name
 
 ### Animation Editor
 - Frame picker with visual thumbnails
@@ -52,8 +56,53 @@ Dynamic: license-file
 
 ## Install (local/dev)
 
+### Using Virtual Environment (Recommended)
+
+For Linux and macOS:
+
 ```bash
+# Create virtual environment
+python3 -m venv .venv
+
+# Activate virtual environment
+source .venv/bin/activate
+
+# Install in development mode
+pip install -e .
+
+# Deactivate when done
+deactivate
+```
+
+For Windows:
+
+```bash
+# Create virtual environment
+python -m venv .venv
+
+# Activate virtual environment
+.venv\Scripts\activate
+
+# Install in development mode
 pip install -e .
+
+# Deactivate when done
+deactivate
+```
+
+### Direct Install (Not Recommended)
+
+```bash
+pip install -e .
+```
+
+## Package installtion from pypi
+
+```bash
+pip install tilemap-editor
+```
+```bash
+pip install tilemap-parser
 ```
 
 ## Run editor

{tilemap_editor-2.0.0 → tilemap_editor-2.0.2}/README.md

@@ -1,24 +1,28 @@
 # tilemap-editor
 
+> [!WARNING]
+> This is mostly vibe coded as working with ui isnt so easy in pygame. Somehow it works for me. Though it took decent time as this was initially too buggy(which still is as expected). Just an experiment and keep customizing for my need.
+PRs are welcome.
+
 `tilemap-editor` is a pygame-based map editor focused on fast iteration for 2D games.
+`tilemap-parser` to parse this editor. (https://pypi.org/project/tilemap-parser/)[https://pypi.org/project/tilemap-parser/]
 
 ## What it includes
 
 - **Multi-layer tile/object map editing** with visual layer management
-- **Professional UI** with SVG icons, consistent fonts, and modern design
+- **Decent enough UI** with SVG icons, consistent fonts, and modern design
 - **Sprite animation editor** (`tilemap-anim-editor`) with frame-by-frame editing
 - **Built-in tools**: File manager, error console, image viewer, automapper
 - **Font management** with auto-selected coding fonts for clarity
 - **Icon system** with 26+ SVG icons and geometric fallbacks
 - **JSON save/load** compatible with this editor
+- **Decent console** toggled with ctrl + ` for error/warning/logs/debugging
 
 ## Key Features
 
 ### UI Improvements
-- Crisp SVG icons throughout the interface
+- SVG icons throughout the interface
 - Bold, auto-selected coding fonts (JetBrains Mono, Fira Code, Consolas)
-- Professional color scheme and consistent styling
-- Dynamic icon loading - icons auto-load by button name
 
 ### Animation Editor
 - Frame picker with visual thumbnails
@@ -36,8 +40,53 @@
 
 ## Install (local/dev)
 
+### Using Virtual Environment (Recommended)
+
+For Linux and macOS:
+
 ```bash
+# Create virtual environment
+python3 -m venv .venv
+
+# Activate virtual environment
+source .venv/bin/activate
+
+# Install in development mode
+pip install -e .
+
+# Deactivate when done
+deactivate
+```
+
+For Windows:
+
+```bash
+# Create virtual environment
+python -m venv .venv
+
+# Activate virtual environment
+.venv\Scripts\activate
+
+# Install in development mode
 pip install -e .
+
+# Deactivate when done
+deactivate
+```
+
+### Direct Install (Not Recommended)
+
+```bash
+pip install -e .
+```
+
+## Package installtion from pypi
+
+```bash
+pip install tilemap-editor
+```
+```bash
+pip install tilemap-parser
 ```
 
 ## Run editor

{tilemap_editor-2.0.0 → tilemap_editor-2.0.2}/pyproject.toml

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

{tilemap_editor-2.0.0 → tilemap_editor-2.0.2}/src/editor.py

@@ -490,6 +490,9 @@ class Editor:
                 self._init_animation_panel()
             if self.animation_panel is not None:
                 self.left_panel_visible = True
+        else:
+            self.left_panel_visible = False
+
 
     def _init_animation_panel(self):
         """Initialize the animation panel without loading any tileset."""
@@ -605,6 +608,87 @@ 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.
+
+        Uses the active tileset image when one is loaded. If no tileset is
+        selected, shows a notification.
+        """
+        sheet = self._active_tileset_image_path()
+        if sheet is not None:
+            self._launch_collision_editor_with_image(sheet)
+            return
+
+        self.notifications.notify("No tileset loaded. Please load a tileset first.")
+
+    def _launch_collision_editor_with_image(self, path: Path):
+        """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})"
+            )
+        except Exception as e:
+            error_handler.capture(e, context="launch_collision_editor")
+
+    def launch_character_collision_editor(self):
+        """Launch the character collision editor in a new window.
+
+        Opens a file picker to select a character sprite image.
+        """
+        self.open_file_manager(
+            on_select=self._launch_character_collision_editor_with_image,
+            initial_dir=BASE_PATH / "data",
+            allowed_exts=[".png", ".jpg", ".jpeg"],
+            mode="open",
+        )
+
+    def _launch_character_collision_editor_with_image(self, path: Path):
+        """Launch character collision editor subprocess with selected image."""
+        try:
+            # Use filename (without extension) as default character name
+            character_name = path.stem
+
+            args = [str(path), "--name", character_name]
+            
+            # 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.character_collision.standalone",
+                args,
+                cwd=BASE_PATH,
+                text=True,
+            )
+            self.child_processes.append(process)
+
+            print(
+                f"Launched character collision editor with: {path.name} (character: {character_name})"
+            )
+        except Exception as e:
+            error_handler.capture(e, context="launch_character_collision_editor")
+
     def launch_error_console(self):
         """Launch the error console as a subprocess."""
         if self.error_console_process and self.error_console_process.poll() is None:
@@ -670,6 +754,7 @@ class Editor:
         self.child_processes = [p for p in self.child_processes if p.poll() is None]
 
     def handle_events(self):
+        """Process all pygame events."""
         for event in pygame.event.get():
             if event.type == pygame.QUIT:
                 self.running = False

tilemap_editor-2.0.2/src/plugins/character_collision/__init__.py

@@ -0,0 +1,24 @@
+"""
+Character Collision Editor Plugin
+
+Editor for defining collision shapes for character sprites.
+Supports rectangle, circle, capsule, and polygon shapes.
+"""
+
+from .models import (
+    CharacterCollisionData,
+    RectangleCollisionData,
+    CircleCollisionData,
+    CapsuleCollisionData,
+    PolygonCollisionData,
+)
+from .protocols import CollisionShapeType
+
+__all__ = [
+    "CharacterCollisionData",
+    "RectangleCollisionData",
+    "CircleCollisionData",
+    "CapsuleCollisionData",
+    "PolygonCollisionData",
+    "CollisionShapeType",
+]

tilemap_editor-2.0.2/src/plugins/character_collision/editor.py

@@ -0,0 +1,320 @@
+"""
+Character Collision Editor — Define collision shapes for character sprites.
+
+Layout:
+    +----------------------------------------------------+
+    | Toolbar: [Character Name] [Shape Type Buttons]    |
+    +----------------------------------------------------+
+    |                                                    |
+    |              Shape Editor                          |
+    |              (visual shape editing)                |
+    |                                                    |
+    +----------------------------------------------------+
+    | Properties: [Width/Height/Radius/etc.]             |
+    +----------------------------------------------------+
+"""
+
+from __future__ import annotations
+
+from typing import Optional, Tuple, Dict, Any
+from pathlib import Path
+
+import pygame
+from pygame import Rect, Surface
+
+from .models import CharacterCollisionData
+from .shape_editor import ShapeEditor, ShapeType
+from utils.font_manager import font_manager, FontWeight
+from utils.icon_manager import icon_manager
+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
+
+
+class CharacterCollisionEditor:
+    """Main editor for character collision shapes."""
+
+    def __init__(
+        self,
+        rect: Rect,
+        sprite_surface: Surface,
+        character_name: str = "Character",
+    ):
+        self.rect = rect
+        self.sprite_surface = sprite_surface
+        self.character_name = character_name
+        self.visible = True
+
+        # UI layout
+        self.toolbar_height = 50
+        self.properties_height = 100
+
+        shape_editor_rect = Rect(
+            rect.x,
+            rect.y + self.toolbar_height,
+            rect.w,
+            rect.h - self.toolbar_height - self.properties_height
+        )
+
+        # Shape editor
+        self.shape_editor = ShapeEditor(shape_editor_rect, sprite_surface)
+
+        # 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)
+
+        # Shape type buttons
+        self.shape_buttons: Dict[ShapeType, Rect] = {}
+        self._init_shape_buttons()
+
+    def _init_shape_buttons(self) -> None:
+        """Initialize shape type button rects"""
+        button_w = 100
+        button_h = 30
+        button_spacing = 10
+        start_x = self.rect.x + 250
+
+        shapes: list[ShapeType] = ["rectangle", "circle", "capsule"]
+        for i, shape in enumerate(shapes):
+            x = start_x + i * (button_w + button_spacing)
+            y = self.rect.y + 10
+            self.shape_buttons[shape] = Rect(x, y, button_w, button_h)
+
+    def resize(self, rect: Rect) -> None:
+        """Resize the editor"""
+        self.rect = rect
+
+        shape_editor_rect = Rect(
+            rect.x,
+            rect.y + self.toolbar_height,
+            rect.w,
+            rect.h - self.toolbar_height - self.properties_height
+        )
+
+        self.shape_editor.resize(shape_editor_rect)
+        self._init_shape_buttons()
+
+    def get_collision_data(self) -> CharacterCollisionData:
+        """Get the current collision data"""
+        shape_data = self.shape_editor.get_shape_data()
+        
+        # Import shape data classes
+        from .models import (
+            RectangleCollisionData,
+            CircleCollisionData,
+            CapsuleCollisionData,
+            PolygonCollisionData,
+        )
+
+        shape_type = shape_data["type"]
+        if shape_type == "rectangle":
+            shape = RectangleCollisionData(
+                width=shape_data["width"],
+                height=shape_data["height"],
+                offset=shape_data["offset"],
+            )
+        elif shape_type == "circle":
+            shape = CircleCollisionData(
+                radius=shape_data["radius"],
+                offset=shape_data["offset"],
+            )
+        elif shape_type == "capsule":
+            shape = CapsuleCollisionData(
+                radius=shape_data["radius"],
+                height=shape_data["height"],
+                offset=shape_data["offset"],
+            )
+        elif shape_type == "polygon":
+            shape = PolygonCollisionData(
+                vertices=shape_data["vertices"],
+                offset=shape_data["offset"],
+            )
+        else:
+            raise ValueError(f"Unknown shape type: {shape_type}")
+
+        return CharacterCollisionData(
+            name=self.character_name,
+            shape=shape,
+        )
+
+    def load_collision_data(self, data: CharacterCollisionData) -> None:
+        """Load collision data"""
+        self.character_name = data.name
+        self.shape_editor.load_shape_data(data.shape.to_dict())
+
+    def save_to_file(self, path: Path) -> None:
+        """Save collision data to file"""
+        try:
+            import json
+            data = self.get_collision_data()
+            with open(path, 'w') as f:
+                json.dump(data.to_dict(), f, indent=2)
+        except Exception as e:
+            error_handler.capture(e, context="save_character_collision")
+
+    def load_from_file(self, path: Path) -> None:
+        """Load collision data from file"""
+        try:
+            import json
+            with open(path, 'r') as f:
+                data_dict = json.load(f)
+            data = CharacterCollisionData.from_dict(data_dict)
+            self.load_collision_data(data)
+        except Exception as e:
+            error_handler.capture(e, context="load_character_collision")
+
+    def handle_event(self, event: pygame.event.Event) -> bool:
+        """Handle input events"""
+        if not self.visible:
+            return False
+
+        # Let shape editor handle events first
+        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():
+                if button_rect.collidepoint(mouse):
+                    self.shape_editor.set_shape_type(shape_type)
+                    return True
+
+        return False
+
+    def draw(self, screen: Surface) -> None:
+        """Draw the editor"""
+        if not self.visible:
+            return
+
+        # Draw toolbar
+        self._draw_toolbar(screen)
+
+        # Draw shape editor
+        self.shape_editor.draw(screen)
+
+        # Draw properties panel
+        self._draw_properties(screen)
+
+    def _draw_toolbar(self, screen: Surface) -> None:
+        """Draw the toolbar"""
+        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
+        )
+        screen.blit(title, (toolbar_rect.x + 10, toolbar_rect.y + 15))
+
+        # Shape type buttons
+        for shape_type, button_rect in self.shape_buttons.items():
+            is_active = (self.shape_editor.shape_type == shape_type)
+            
+            # Render label
+            label_surf = self._font_sm.render(shape_type.capitalize(), True, COLORS.text)
+            
+            draw_button(screen, button_rect, label_surf, active=is_active)
+
+    def _draw_properties(self, screen: Surface) -> None:
+        """Draw the properties panel"""
+        props_rect = Rect(
+            self.rect.x,
+            self.rect.bottom - self.properties_height,
+            self.rect.w,
+            self.properties_height
+        )
+        draw_panel(screen, props_rect, COLORS.panel, COLORS.border)
+
+        # Display current shape properties
+        shape_data = self.shape_editor.get_shape_data()
+        y = props_rect.y + 10
+        x = props_rect.x + 10
+
+        title = self._font.render("Properties:", True, COLORS.text)
+        screen.blit(title, (x, y))
+        y += 25
+
+        if shape_data["type"] == "rectangle":
+            text = self._font_sm.render(
+                f"Width: {shape_data['width']:.1f}  Height: {shape_data['height']:.1f}  Offset: ({shape_data['offset'][0]:.1f}, {shape_data['offset'][1]:.1f})",
+                True,
+                COLORS.text_dim
+            )
+            screen.blit(text, (x, y))
+        elif shape_data["type"] == "circle":
+            text = self._font_sm.render(
+                f"Radius: {shape_data['radius']:.1f}  Offset: ({shape_data['offset'][0]:.1f}, {shape_data['offset'][1]:.1f})",
+                True,
+                COLORS.text_dim
+            )
+            screen.blit(text, (x, y))
+        elif shape_data["type"] == "capsule":
+            text = self._font_sm.render(
+                f"Radius: {shape_data['radius']:.1f}  Height: {shape_data['height']:.1f}  Offset: ({shape_data['offset'][0]:.1f}, {shape_data['offset'][1]:.1f})",
+                True,
+                COLORS.text_dim
+            )
+            screen.blit(text, (x, y))
+        elif shape_data["type"] == "polygon":
+            vertex_count = len(shape_data["vertices"])
+            text = self._font_sm.render(
+                f"Vertices: {vertex_count}",
+                True,
+                COLORS.text_dim
+            )
+            screen.blit(text, (x, y))
+
+    @classmethod
+    def from_path(
+        cls,
+        sprite_path: Path,
+        window_size: Tuple[int, int] = (1000, 800),
+        character_name: str = "Character",
+    ) -> "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)
+
+    def run(self) -> None:
+        """Run standalone editor (for standalone use)"""
+        screen = pygame.display.get_surface()
+        if screen is None:
+            raise RuntimeError("pygame display not initialized")
+
+        clock = pygame.time.Clock()
+        running = True
+
+        while running:
+            for event in pygame.event.get():
+                if event.type == pygame.QUIT:
+                    running = False
+                elif event.type == pygame.KEYDOWN:
+                    if event.key == pygame.K_ESCAPE:
+                        running = False
+                    elif event.key == pygame.K_s and (
+                        pygame.key.get_mods() & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
+                    ):
+                        # Ctrl+S / Cmd+S to save
+                        save_path = Path("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")
+                        if load_path.exists():
+                            self.load_from_file(load_path)
+                            print(f"Loaded collision data from {load_path}")
+
+                self.handle_event(event)
+
+            screen.fill((20, 20, 20))
+            self.draw(screen)
+            pygame.display.flip()
+            clock.tick(60)