tilemap-editor 3.0.1__tar.gz → 3.1.2__tar.gz

{tilemap_editor-3.0.1/src/tilemap_editor.egg-info → tilemap_editor-3.1.2}/PKG-INFO

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

{tilemap_editor-3.0.1 → tilemap_editor-3.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.0.1"
+version = "3.1.2"
 description = "Pygame tilemap editor with SVG icons, professional UI, and sprite animation tools"
 readme = "README.md"
 requires-python = ">=3.10"
@@ -33,7 +33,6 @@ py-modules = [
   "event_map",
   "layers",
   "tilemap",
-  "tilemap_parser",
   "standalone_filemanager",
   "standalone_image_viewer",
   "standalone_automap",

{tilemap_editor-3.0.1 → tilemap_editor-3.1.2}/src/plugins/character_collision/editor.py

@@ -29,6 +29,7 @@ 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
+from widgets.ui.collision_layer_sidebar import CollisionLayerSidebar
 
 
 class CharacterCollisionEditor:
@@ -60,6 +61,14 @@ class CharacterCollisionEditor:
         # Shape editor
         self.shape_editor = ShapeEditor(shape_editor_rect, sprite_surface)
 
+        # Collision layer/mask sidebar (toggleable overlay)
+        self.layer_sidebar = CollisionLayerSidebar(
+            rect,
+            max_layers=16,
+            initial_layer=1,
+            initial_mask=0xFFFF,
+        )
+
         # 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)
@@ -93,6 +102,8 @@ class CharacterCollisionEditor:
         )
 
         self.shape_editor.resize(shape_editor_rect)
+        self.layer_sidebar.resize(rect)
+
         self._init_shape_buttons()
 
     def get_collision_data(self) -> CharacterCollisionData:
@@ -136,12 +147,20 @@ class CharacterCollisionEditor:
         return CharacterCollisionData(
             name=self.character_name,
             shape=shape,
+            properties={
+                "collision_layer": self.layer_sidebar.get_layer(),
+                "collision_mask": self.layer_sidebar.get_mask(),
+            },
         )
 
     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())
+        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_collision_dir(self) -> Path:
         """Get collision data directory (data_root/character_collision)"""
@@ -175,7 +194,22 @@ class CharacterCollisionEditor:
         if not self.visible:
             return False
 
-        # Let shape editor handle events first
+        # Layer/mask sidebar handles events when open
+        if self.layer_sidebar.handle_event(event):
+            return True
+
+        # Toggle button
+        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:
+            mods = pygame.key.get_mods()
+            if not (mods & (pygame.KMOD_CTRL | pygame.KMOD_LMETA)):
+                self.layer_sidebar.toggle()
+                return True
+
+        # Let shape editor handle events next
         if self.shape_editor.handle_event(event):
             return True
 
@@ -201,6 +235,12 @@ class CharacterCollisionEditor:
         # Draw shape editor
         self.shape_editor.draw(screen)
 
+        # Draw toggle button
+        self.layer_sidebar.draw_toggle_button(screen)
+
+        # Draw collision layer/mask sidebar (only when visible)
+        self.layer_sidebar.draw(screen)
+
         # Draw properties panel
         self._draw_properties(screen)
 

{tilemap_editor-3.0.1 → tilemap_editor-3.1.2}/src/plugins/character_collision/shape_editor.py

@@ -18,6 +18,7 @@ import pygame
 from pygame import Rect
 from utils.font_manager import font_manager, FontWeight
 from utils.error_handler import error_handler
+from utils.icon_manager import icon_manager
 
 
 ShapeType = Literal["rectangle", "circle", "capsule", "polygon"]
@@ -82,8 +83,14 @@ class ShapeEditor:
         self.dragging_handle: Optional[str] = None
         self.hover_handle: Optional[str] = None
         self._panning = False
+        self._pan_mode = False
         self._pan_start = (0, 0)
         self._pan_start_offset = (0.0, 0.0)
+        self._move_icon_pos: Tuple[int, int] = (0, 0)
+        self._move_icon_hover = False
+        self._dragging_shape = False
+        self._drag_start = (0, 0)
+        self._drag_start_positions: dict = {}
         
         # Settings
         self.show_grid = True
@@ -95,6 +102,7 @@ class ShapeEditor:
         
         # Center the sprite
         self._center_view()
+        self._center_shape()
     
     def _center_view(self) -> None:
         """Center the sprite in the viewport"""
@@ -102,6 +110,27 @@ class ShapeEditor:
         self.offset_x = (self.rect.w - sw * self.zoom) / 2
         self.offset_y = (self.rect.h - sh * self.zoom) / 2
     
+    def _center_shape(self) -> None:
+        """Center all shape types on the sprite"""
+        sw, sh = self.sprite_surface.get_size()
+        
+        # Rectangle: 50% of sprite, centered
+        self.rect_w = sw * 0.5
+        self.rect_h = sh * 0.5
+        self.rect_x = (sw - self.rect_w) / 2
+        self.rect_y = (sh - self.rect_h) / 2
+        
+        # Circle: 25% of min dimension, centered
+        self.circle_radius = min(sw, sh) * 0.25
+        self.circle_x = sw / 2
+        self.circle_y = sh / 2
+        
+        # Capsule: 50% height, 15% width radius, centered
+        self.capsule_height = sh * 0.5
+        self.capsule_radius = sw * 0.15
+        self.capsule_x = sw / 2
+        self.capsule_y = (sh - self.capsule_height) / 2
+    
     def _ensure_fonts(self) -> None:
         """Initialize fonts"""
         if self._font is None:
@@ -182,6 +211,7 @@ class ShapeEditor:
     def resize(self, rect: Rect) -> None:
         """Update rect"""
         self.rect = rect
+        self._center_view()
     
     def handle_event(self, event: pygame.event.Event) -> bool:
         """Handle input events"""
@@ -190,6 +220,7 @@ class ShapeEditor:
         if not self.rect.collidepoint(mouse) and event.type not in (
             pygame.MOUSEBUTTONUP,
             pygame.MOUSEMOTION,
+            pygame.KEYDOWN,
         ):
             return False
         
@@ -214,14 +245,25 @@ class ShapeEditor:
                 self.offset_y = self._pan_start_offset[1] + dy
                 return True
             
-            # Update hover state
-            if self.rect.collidepoint(mouse):
-                self.hover_handle = self._find_handle_at(mouse)
-            
-            # Drag handle
+            # Drag handle — always takes priority over shape drag
             if self.dragging_handle:
                 self._drag_handle(mouse)
                 return True
+            
+            # Drag entire shape via move icon
+            if self._dragging_shape:
+                dx = (mouse[0] - self._drag_start[0]) / self.zoom
+                dy = (mouse[1] - self._drag_start[1]) / self.zoom
+                self._apply_shape_delta(dx, dy)
+                return True
+            
+            # Update hover state
+            if self.rect.collidepoint(mouse):
+                handle = self._find_handle_at(mouse)
+                if handle:
+                    self.hover_handle = handle
+                else:
+                    self.hover_handle = None
         
         # Mouse wheel to zoom
         if event.type == pygame.MOUSEWHEEL and self.rect.collidepoint(mouse):
@@ -238,10 +280,25 @@ class ShapeEditor:
         # Left click
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
             if self.rect.collidepoint(mouse):
+                # Pan mode — start dragging
+                if self._pan_mode:
+                    self._panning = True
+                    self._pan_start = mouse
+                    self._pan_start_offset = (self.offset_x, self.offset_y)
+                    return True
+                
                 # Check if clicking on handle
                 handle = self._find_handle_at(mouse)
                 if handle:
                     self.dragging_handle = handle
+                    self._dragging_shape = False
+                    return True
+                
+                # Check if clicking on move icon
+                if self._is_on_move_icon(mouse) and not self._pan_mode:
+                    self._dragging_shape = True
+                    self._drag_start = mouse
+                    self._save_shape_positions()
                     return True
                 
                 # Polygon mode - add vertex
@@ -256,6 +313,12 @@ class ShapeEditor:
                     return True
         
         if event.type == pygame.MOUSEBUTTONUP and event.button == 1:
+            if self._panning:
+                self._panning = False
+                return True
+            if self._dragging_shape:
+                self._dragging_shape = False
+                return True
             if self.dragging_handle:
                 self.dragging_handle = None
                 return True
@@ -270,7 +333,13 @@ class ShapeEditor:
         
         # Keyboard shortcuts
         if event.type == pygame.KEYDOWN:
-            if event.key == pygame.K_g:
+            if event.key == pygame.K_SPACE:
+                self._pan_mode = not self._pan_mode
+                if self._pan_mode:
+                    self._pan_start = mouse
+                    self._pan_start_offset = (self.offset_x, self.offset_y)
+                return True
+            elif event.key == pygame.K_g:
                 self.show_grid = not self.show_grid
                 return True
             elif event.key == pygame.K_r:
@@ -344,14 +413,22 @@ class ShapeEditor:
         
         if self.shape_type == "rectangle":
             if self.dragging_handle == "tl":
+                old_right = self.rect_x + self.rect_w
+                old_bottom = self.rect_y + self.rect_h
                 self.rect_x = max(0, min(sw, sprite_pos[0]))
                 self.rect_y = max(0, min(sh, sprite_pos[1]))
+                self.rect_w = max(1, old_right - self.rect_x)
+                self.rect_h = max(1, old_bottom - self.rect_y)
             elif self.dragging_handle == "tr":
+                old_bottom = self.rect_y + self.rect_h
                 self.rect_w = max(1, sprite_pos[0] - self.rect_x)
                 self.rect_y = max(0, min(sh, sprite_pos[1]))
+                self.rect_h = max(1, old_bottom - self.rect_y)
             elif self.dragging_handle == "bl":
+                old_right = self.rect_x + self.rect_w
                 self.rect_x = max(0, min(sw, sprite_pos[0]))
                 self.rect_h = max(1, sprite_pos[1] - self.rect_y)
+                self.rect_w = max(1, old_right - self.rect_x)
             elif self.dragging_handle == "br":
                 self.rect_w = max(1, sprite_pos[0] - self.rect_x)
                 self.rect_h = max(1, sprite_pos[1] - self.rect_y)
@@ -368,12 +445,102 @@ class ShapeEditor:
         
         elif self.shape_type == "capsule":
             if self.dragging_handle == "top":
+                old_bottom = self.capsule_y + self.capsule_height
                 self.capsule_y = max(0, min(sh, sprite_pos[1]))
+                self.capsule_height = max(1, old_bottom - self.capsule_y)
             elif self.dragging_handle == "bottom":
                 self.capsule_height = max(1, sprite_pos[1] - self.capsule_y)
             elif self.dragging_handle == "radius":
                 self.capsule_radius = max(1, abs(sprite_pos[0] - self.capsule_x))
     
+    def _get_move_icon_pos(self) -> Tuple[int, int]:
+        """Get screen position for the move icon at mid-top of the shape"""
+        if self.shape_type == "rectangle":
+            mid_x = self.rect_x + self.rect_w / 2
+            top_y = self.rect_y
+            return self._sprite_to_screen((mid_x, top_y))
+        elif self.shape_type == "circle":
+            return self._sprite_to_screen((self.circle_x, self.circle_y - self.circle_radius))
+        elif self.shape_type == "capsule":
+            return self._sprite_to_screen((self.capsule_x, self.capsule_y))
+        elif self.shape_type == "polygon" and len(self.polygon_vertices) >= 3:
+            # Top-center of polygon bounding box
+            min_y = min(v[1] for v in self.polygon_vertices)
+            mid_x = (min(v[0] for v in self.polygon_vertices) + max(v[0] for v in self.polygon_vertices)) / 2
+            return self._sprite_to_screen((mid_x, min_y))
+        return (0, 0)
+    
+    def _is_on_move_icon(self, screen_pos: Tuple[int, int]) -> bool:
+        """Check if a screen position is on the move icon (16x16 hit area)"""
+        icon_pos = self._get_move_icon_pos()
+        self._move_icon_pos = icon_pos
+        hit_size = 16
+        half = hit_size // 2
+        return (icon_pos[0] - half <= screen_pos[0] <= icon_pos[0] + half and
+                icon_pos[1] - half <= screen_pos[1] <= icon_pos[1] + half)
+    
+    def _is_inside_shape(self, screen_pos: Tuple[int, int]) -> bool:
+        """Check if a screen position is inside the current shape (for hover detection)"""
+        if self.shape_type == "rectangle":
+            tl = self._sprite_to_screen((self.rect_x, self.rect_y))
+            br = self._sprite_to_screen((self.rect_x + self.rect_w, self.rect_y + self.rect_h))
+            return (tl[0] <= screen_pos[0] <= br[0] and tl[1] <= screen_pos[1] <= br[1])
+        
+        elif self.shape_type == "circle":
+            center = self._sprite_to_screen((self.circle_x, self.circle_y))
+            radius = int(self.circle_radius * self.zoom)
+            return math.hypot(screen_pos[0] - center[0], screen_pos[1] - center[1]) <= radius
+        
+        elif self.shape_type == "capsule":
+            top = self._sprite_to_screen((self.capsule_x, self.capsule_y))
+            bottom = self._sprite_to_screen((self.capsule_x, self.capsule_y + self.capsule_height))
+            radius = int(self.capsule_radius * self.zoom)
+            if math.hypot(screen_pos[0] - top[0], screen_pos[1] - top[1]) <= radius:
+                return True
+            if math.hypot(screen_pos[0] - bottom[0], screen_pos[1] - bottom[1]) <= radius:
+                return True
+            left = top[0] - radius
+            right = top[0] + radius
+            return left <= screen_pos[0] <= right and top[1] <= screen_pos[1] <= bottom[1]
+        
+        elif self.shape_type == "polygon" and len(self.polygon_vertices) >= 3:
+            px, py = self._screen_to_sprite(screen_pos)
+            n = len(self.polygon_vertices)
+            inside = False
+            j = n - 1
+            for i in range(n):
+                vi = self.polygon_vertices[i]
+                vj = self.polygon_vertices[j]
+                if ((vi[1] > py) != (vj[1] > py)) and (
+                    px < (vj[0] - vi[0]) * (py - vi[1]) / (vj[1] - vi[1]) + vi[0]
+                ):
+                    inside = not inside
+                j = i
+            return inside
+        
+        return False
+    
+    def _save_shape_positions(self) -> None:
+        """Store current shape positions for delta calculation"""
+        self._drag_start_positions = {
+            "rect": (self.rect_x, self.rect_y),
+            "circle": (self.circle_x, self.circle_y),
+            "capsule": (self.capsule_x, self.capsule_y),
+        }
+    
+    def _apply_shape_delta(self, dx: float, dy: float) -> None:
+        """Move shape by delta in sprite-local coordinates"""
+        sw, sh = self.sprite_surface.get_size()
+        if self.shape_type == "rectangle":
+            self.rect_x = max(0, min(sw - self.rect_w, self._drag_start_positions["rect"][0] + dx))
+            self.rect_y = max(0, min(sh - self.rect_h, self._drag_start_positions["rect"][1] + dy))
+        elif self.shape_type == "circle":
+            self.circle_x = max(0, min(sw, self._drag_start_positions["circle"][0] + dx))
+            self.circle_y = max(0, min(sh, self._drag_start_positions["circle"][1] + dy))
+        elif self.shape_type == "capsule":
+            self.capsule_x = max(0, min(sw, self._drag_start_positions["capsule"][0] + dx))
+            self.capsule_y = max(0, min(sh - self.capsule_height, self._drag_start_positions["capsule"][1] + dy))
+    
     def draw(self, screen: pygame.Surface) -> None:
         """Draw the shape editor"""
         self._ensure_fonts()
@@ -406,6 +573,14 @@ class ShapeEditor:
         # Draw shape
         self._draw_shape(screen)
         
+        # Draw move icon at mid-top when hovering over shape body
+        if not self._pan_mode and not self.hover_handle:
+            mouse = pygame.mouse.get_pos()
+            if self.rect.collidepoint(mouse) and self._is_inside_shape(mouse):
+                icon_pos = self._get_move_icon_pos()
+                icon = icon_manager.get_icon("ToolMove", 16, _COLORS["shape_stroke"])
+                screen.blit(icon, (icon_pos[0] - 8, icon_pos[1] - 8))
+        
         # Draw status
         self._draw_status(screen)
         
@@ -544,6 +719,10 @@ class ShapeEditor:
     def _draw_status(self, screen: pygame.Surface) -> None:
         """Draw status text"""
         lines = []
+        
+        if self._pan_mode:
+            lines.append("PANNING MODE — drag to pan | Space to exit")
+        
         lines.append(f"Shape: {self.shape_type.upper()} | Zoom: {self.zoom:.1f}x")
         
         if self.shape_type == "polygon":
@@ -554,7 +733,7 @@ class ShapeEditor:
             else:
                 lines.append("Click to add vertices")
         
-        lines.append("G: toggle grid | R: reset view | Mouse wheel: zoom")
+        lines.append("G: toggle grid | R: reset view | Space: pan mode | Wheel: zoom")
         
         y = self.rect.y + 5
         for line in lines:

{tilemap_editor-3.0.1 → tilemap_editor-3.1.2}/src/plugins/object_tileset_collision/editor.py

@@ -39,6 +39,7 @@ from widgets.ui.status_bar import StatusBar, StatusType
 from widgets.ui.mode_indicator import ModeIndicator, Mode
 from widgets.ui.draw_utils import draw_panel, draw_button
 from widgets.ui.theme import COLORS, FONTS, SHAPE
+from widgets.ui.collision_layer_sidebar import CollisionLayerSidebar
 from widgets.input import InlineTextInput
 from utils.font_manager import font_manager, FontWeight
 from utils.icon_manager import icon_manager
@@ -190,6 +191,15 @@ class ObjectTilesetCollisionEditor:
             show_icons=True,
         )
 
+        # Collision layer/mask sidebar (toggleable overlay)
+        self.layer_sidebar = CollisionLayerSidebar(
+            self.rect,
+            max_layers=16,
+            initial_layer=1,
+            initial_mask=0xFFFF,
+            on_changed=self._on_layer_mask_changed,
+        )
+
         # Collision painter (middle area)
         self.painter = CollisionPainter(
             self.painter_rect,
@@ -245,6 +255,8 @@ class ObjectTilesetCollisionEditor:
             self.status_bar.resize(self.status_bar_rect)
         if hasattr(self, 'painter'):
             self.painter.resize(self.painter_rect)
+        if hasattr(self, 'layer_sidebar'):
+            self.layer_sidebar.resize(self.rect)
         
         # Mode indicator position (in toolbar, centered)
         if hasattr(self, 'mode_indicator'):
@@ -332,6 +344,14 @@ class ObjectTilesetCollisionEditor:
         """Called when region selection changes"""
         self._current_region_id = region_id
         
+        # Load layer/mask from region properties
+        if region_id and region_id in self.library.regions:
+            data = self.library.regions[region_id]
+            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)
+        
         # Update painter to show selected region
         if self._mode == EditorMode.PAINT_COLLISION:
             self._update_painter_for_current_region()
@@ -366,6 +386,12 @@ class ObjectTilesetCollisionEditor:
         
         return status
 
+    def _on_layer_mask_changed(self, layer: int, mask: int) -> None:
+        """Called when collision layer/mask widget changes."""
+        if self._current_region_id and self._current_region_id in self.library.regions:
+            self.library.regions[self._current_region_id].properties["collision_layer"] = layer
+            self.library.regions[self._current_region_id].properties["collision_mask"] = mask
+
     # === Rename Functionality ===
 
     def _start_rename(self, region_id: str) -> None:
@@ -805,6 +831,19 @@ class ObjectTilesetCollisionEditor:
             if self.region_selector.handle_event(event):
                 return True
         
+        # Priority 5.5: Collision layer/mask sidebar (toggle + events when open)
+        if self.layer_sidebar.handle_event(event):
+            return True
+        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:
+            mods = pygame.key.get_mods()
+            if not (mods & (pygame.KMOD_CTRL | pygame.KMOD_LMETA)):
+                self.layer_sidebar.toggle()
+                return True
+        
         # Priority 6: Collision painter (paint collision mode)
         if self._mode == EditorMode.PAINT_COLLISION:
             if self.painter.handle_event(event):
@@ -902,6 +941,12 @@ class ObjectTilesetCollisionEditor:
         # Draw status bar
         self.status_bar.draw(screen)
         
+        # Draw toggle button
+        self.layer_sidebar.draw_toggle_button(screen)
+        
+        # Draw collision layer/mask sidebar (only when visible)
+        self.layer_sidebar.draw(screen)
+        
         # Draw region selector (bottom)
         self.region_selector.draw(screen)
         

{tilemap_editor-3.0.1 → tilemap_editor-3.1.2}/src/tilemap.py

@@ -226,11 +226,13 @@ class Tilemap:
             if path_obj.is_absolute():
                 target_path = path_obj
             else:
-                data_root = getattr(getattr(self, 'editor', None), 'data_root', None)
+                data_root = getattr(getattr(self, "editor", None), "data_root", None)
                 if data_root:
                     target_path = data_root / path_obj
                 else:
-                    raise RuntimeError("Cannot determine data_root - Editor not initialized with settings.json")
+                    raise RuntimeError(
+                        "Cannot determine data_root - Editor not initialized with settings.json"
+                    )
 
             self.active_project_path = target_path
         elif self.active_project_path:
@@ -241,7 +243,7 @@ class Tilemap:
         if not target_path.parent.exists():
             target_path.parent.mkdir(parents=True, exist_ok=True)
 
-        base_path = self._project_base_path()
+        map_dir = target_path.parent
 
         save_data = {
             "meta": {
@@ -279,7 +281,7 @@ class Tilemap:
 
         if hasattr(self.editor, "tileset_widget") and self.editor.tileset_widget:
             for ts in self.editor.tileset_widget.tilesets:
-                path_str = to_project_path(ts.path, base_path)
+                path_str = to_project_path(ts.path, map_dir)
 
                 ts_data: Dict[str, Any] = {"path": path_str, "type": ts.tileset_type}
                 if ts.properties:
@@ -301,7 +303,7 @@ class Tilemap:
                     {
                         "name": group.name,
                         "rules": [
-                            self._serialize_autotile_rule(rule, base_path)
+                            self._serialize_autotile_rule(rule, map_dir)
                             for rule in group.rules
                         ],
                     }
@@ -407,14 +409,16 @@ class Tilemap:
         return data
 
     def _path_matches_project_path(self, stored_path: str, actual_path: Path) -> bool:
-        base_path = self._project_base_path()
+        map_dir = (
+            self.active_project_path.parent if self.active_project_path else Path()
+        )
         stored = Path(stored_path).expanduser()
         actual = Path(actual_path).expanduser()
 
         if stored.is_absolute():
             return stored.resolve() == actual.resolve()
 
-        return stored.as_posix() == to_project_path(actual, base_path)
+        return stored.as_posix() == to_project_path(actual, map_dir)
 
     def _resolve_rule_resources(self, rule: "AutotileRule", ts_widget):
         resolved_ts = None

tilemap_editor-3.1.2/src/tilemap_editor/assets/icons/ToolMove.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16"><g fill="#e0e0e0"><circle cx="8" cy="8" r="2"/><path d="M8 1a1 1 0 0 0-.691.291l-2 2 1.414 1.414 1.293-1.293 1.293 1.293 1.414-1.414-2-2A1 1 0 0 0 8 1zM3.309 5.291l-2 2a1 1 0 0 0 0 1.414l2 2 1.414-1.414L3.43 7.998l1.293-1.293-1.414-1.414zm9.414 0-1.414 1.414 1.293 1.293-1.293 1.293 1.414 1.414 2-2a1 1 0 0 0 0-1.414l-2-2zm-6 6-1.414 1.414 2 2a1 1 0 0 0 1.414 0l2-2-1.414-1.414-1.293 1.293-1.293-1.293z"/></g></svg>

{tilemap_editor-3.0.1 → tilemap_editor-3.1.2/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.0.1 → tilemap_editor-3.1.2}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -101,6 +101,7 @@ src/tilemap_editor/assets/fonts/noto/NotoSans-Bold.ttf
 src/tilemap_editor/assets/fonts/noto/NotoSans-BoldItalic.ttf
 src/tilemap_editor/assets/fonts/noto/NotoSans-Italic.ttf
 src/tilemap_editor/assets/fonts/noto/NotoSans-Regular.ttf
+src/tilemap_editor/assets/icons/ToolMove.svg
 src/tilemap_editor/assets/icons/arrow-down.svg
 src/tilemap_editor/assets/icons/check.svg
 src/tilemap_editor/assets/icons/checked.svg
@@ -156,6 +157,8 @@ src/widgets/mapsetup.py
 src/widgets/regex_automap_designer.py
 src/widgets/tile_grid.py
 src/widgets/tile_selector.py
+src/widgets/ui/collision_layer_mask.py
+src/widgets/ui/collision_layer_sidebar.py
 src/widgets/ui/draw_utils.py
 src/widgets/ui/fileinput.py
 src/widgets/ui/layer_type_dialog.py
@@ -168,4 +171,7 @@ src/widgets/ui/status_bar.py
 src/widgets/ui/theme.py
 src/widgets/ui/tileset_type_dialog.py
 src/widgets/ui/toolbar.py
-src/widgets/ui/tooltip.py
+src/widgets/ui/tooltip.py
+tests/test_collision_layer_mask.py
+tests/test_collision_layer_sidebar.py
+tests/test_project_paths.py

{tilemap_editor-3.0.1 → tilemap_editor-3.1.2}/src/tilemap_editor.egg-info/top_level.txt

@@ -10,7 +10,6 @@ standalone_filemanager
 standalone_image_viewer
 tilemap
 tilemap_editor
-tilemap_parser
 ttypes
 utils
 widgets