tilemap-editor 3.3.2__tar.gz → 3.3.4__tar.gz

{tilemap_editor-3.3.2/src/tilemap_editor.egg-info → tilemap_editor-3.3.4}/PKG-INFO

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

{tilemap_editor-3.3.2 → tilemap_editor-3.3.4}/pyproject.toml

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

{tilemap_editor-3.3.2 → tilemap_editor-3.3.4}/src/editor.py

@@ -35,6 +35,7 @@ from widgets.ui.node_selector import NodeSelector
 from widgets.ui.node_editor import NodeEditor
 from widgets.ui.notification import NotificationManager
 from widgets.ui.property_editor import PropertyEditor
+from widgets.ui.particle_config_dialog import ParticleConfigDialog
 from widgets.ui.tooltip import TooltipManager
 from widgets.ui.theme import get_theme_manager, set_theme, THEMES
 from utils.log_capture import setup_console_log
@@ -192,6 +193,7 @@ class Editor:
         self.tooltip = TooltipManager()
         self.error_console_process: Optional[subprocess.Popen] = None
         self.property_editor: Optional[PropertyEditor] = None
+        self.particle_config_dialog: Optional[ParticleConfigDialog] = None
 
         self.child_processes: List[subprocess.Popen] = []
         self.file_manager_process: Optional[subprocess.Popen] = None
@@ -246,7 +248,7 @@ class Editor:
         self.map_properties_dialog = MapPropertiesDialog(self, Rect(center_x, center_y, 400, 260))
         self.node_manager = NodeManager(self)
         self.node_selector = NodeSelector(self, 0, 65, 260, 240)
-        self.node_editor = NodeEditor(self, 0, 310, 260, 190)
+        self.node_editor = NodeEditor(self, 0, 310, 260, 230)
 
     def open_file_manager(
         self,
@@ -443,6 +445,9 @@ class Editor:
             error_handler.capture(e, context="save_map_selected")
 
     def export_selection_as_png(self):
+        if self.tile_grid_widget is None:
+            self.notifications.notify("No tile grid available", duration=2.0)
+            return
         rect = self.tile_grid_widget.selection_rect
         if rect is None:
             self.notifications.notify("No region selected", duration=2.0)
@@ -458,6 +463,9 @@ class Editor:
         rect = self.tile_grid_widget.selection_rect
         if rect is None:
             return
+        if self.tileset_widget is None:
+            self.notifications.notify("No tileset available", duration=2.0)
+            return
         x1, y1, x2, y2 = rect
         tw, th = self.tilemap.tile_size
         pw = (x2 - x1 + 1) * tw
@@ -811,7 +819,7 @@ class Editor:
                 resolved = None
 
             if not resolved or not resolved.exists():
-                print(f"Could not locate spritesheet for animation file: {path.name}")
+                self.notifications.notify(f"Could not locate spritesheet: {path.name}", duration=2.0)
                 return
 
             args = [
@@ -1135,6 +1143,10 @@ class Editor:
                 if self.property_editor.handle_event(event):
                     continue
 
+            if self.particle_config_dialog and self.particle_config_dialog.active:
+                if self.particle_config_dialog.handle_event(event):
+                    continue
+
             # Priority 2: Autotiler and Regex Designer (block all events when visible)
             if self.autotiler.visible:
                 if self.autotiler.handle_event(event):
@@ -1354,8 +1366,6 @@ class Editor:
                 self.screen.blit(overlay, (0, 0))
                 self.layer_type_dialog.draw(self.screen)
 
-            if self.property_editor and self.property_editor.active:
-                self.property_editor.draw(self.screen)
             if self.loading_state["active"]:
                 overlay = pygame.Surface((self.width, self.height), pygame.SRCALPHA)
                 overlay.fill((0, 0, 0, 180))
@@ -1381,6 +1391,11 @@ class Editor:
                 self.node_selector.draw(self.screen)
             if self.node_editor:
                 self.node_editor.draw(self.screen)
+            # Modal dialogs draw on top of everything
+            if self.property_editor and self.property_editor.active:
+                self.property_editor.draw(self.screen)
+            if self.particle_config_dialog and self.particle_config_dialog.active:
+                self.particle_config_dialog.draw(self.screen)
             self.menubar.draw(self.screen)
             self.tooltip.draw(self.screen)
 

{tilemap_editor-3.3.2 → tilemap_editor-3.3.4}/src/node_manager.py

@@ -100,12 +100,20 @@ class NodeManager:
 
     def create_default_node(self, layer_name: str, node_type: str = "area") -> Node:
         count = len(self.nodes) + 1
+        props: Dict[str, Any] = {}
+        if node_type == "particle_emitter":
+            from widgets.particle_system import get_default_config
+            props = get_default_config()
+            name = f"Emitter {count}"
+        else:
+            name = f"{node_type.capitalize()} {count}"
         return Node(
             node_id=create_node_id(),
-            name=f"{node_type.capitalize()} {count}",
+            name=name,
             node_type=node_type,
             area=NodeRect(x=0, y=0, w=64, h=64),
             layer_name=layer_name,
+            properties=props,
         )
 
     def rename_group(self, old_name: str, new_name: str) -> bool:
@@ -132,6 +140,8 @@ class NodeManager:
     def reorder_node(self, node_id: str, target_node_id: str, before: bool = True) -> None:
         if node_id not in self.nodes or target_node_id not in self.nodes:
             return
+        if node_id == target_node_id:
+            return
         node = self.nodes[node_id]
         keys = list(self.nodes.keys())
         keys.remove(node_id)

{tilemap_editor-3.3.2 → tilemap_editor-3.3.4}/src/plugins/sprite_animation/preview.py

@@ -416,7 +416,8 @@ class AnimationPreview:
 
     def _extract_tile(self, variant_id: int) -> Optional[pygame.Surface]:
         tw, th = self.tile_size
-        ox, oy = self.grid_offset_x, self.grid_offset_y
+        ox = self.grid_offset_x
+        oy = self.grid_offset_y
         available_w = self.surface.get_width() - ox
         cols = max(1, available_w // tw)
         col = variant_id % cols

{tilemap_editor-3.3.2 → tilemap_editor-3.3.4}/src/plugins/sprite_editor/editor.py

@@ -149,6 +149,24 @@ class SpriteEditor:
                     if self.grid.redo():
                         self.grid.selected_indices.clear()
                     return True
+                elif event.key == pygame.K_c:
+                    if self.grid.has_selection():
+                        self._clipboard = self.grid.copy_selected()
+                        self._paste_mode = False
+                        self.grid.paste_preview_idx = -1
+                    return True
+                elif event.key == pygame.K_x:
+                    if self.grid.has_selection():
+                        self._clipboard = self.grid.cut_selected()
+                        self._paste_mode = False
+                        self.grid.paste_preview_idx = -1
+                    return True
+                elif event.key == pygame.K_v:
+                    if self._clipboard:
+                        self._paste_mode = not self._paste_mode
+                        if not self._paste_mode:
+                            self.grid.paste_preview_idx = -1
+                    return True
 
         # Toolbar clicks
         if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
@@ -156,19 +174,20 @@ class SpriteEditor:
                 if r.collidepoint(mouse):
                     return self._handle_tool(lbl)
 
-        # Paste mode: next grid click pastes
+        # Paste mode: click places (or exits if outside grid)
         if self._paste_mode and event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
             idx = self.grid.index_at_pos(mouse)
             if idx >= 0 and self.grid.rect.collidepoint(mouse):
                 self.grid.paste_at(idx, self._clipboard)
-                self._paste_mode = False
-                self.grid.paste_preview_idx = -1
-                return True
+            self._paste_mode = False
+            self.grid.paste_preview_idx = -1
+            return True
 
-        # Paste preview on hover
+        # Paste preview on hover (consume event to prevent grid overlap)
         if self._paste_mode and event.type == pygame.MOUSEMOTION:
             idx = self.grid.index_at_pos(mouse)
             self.grid.paste_preview_idx = idx if idx >= 0 else -1
+            return True
 
         return self.grid.handle_event(event)
 

{tilemap_editor-3.3.2 → tilemap_editor-3.3.4}/src/plugins/tileset_collision/collision_painter.py

@@ -117,7 +117,8 @@ class CollisionPainter:
         self.snap_to_grid = False
         self.grid_size = 8  # pixels
         self.show_grid = True
-        self.edge_draw_mode = False  # E key - straight line drawing
+        self.show_angle_hints = False  # show angle arcs at vertices
+        self.edge_draw_mode = False  # Ctrl+E - straight line drawing
         self._edge_start: Optional[Tuple[int, int]] = None  # Start point for edge draw
         self._shift_held = False
         
@@ -270,7 +271,66 @@ class CollisionPainter:
     def get_one_way_flags(self) -> List[bool]:
         """Get one-way collision flags for all polygons"""
         return list(self.polygon_one_way)
+
+    def toggle_one_way(self) -> None:
+        """Toggle one-way flag on the selected polygon"""
+        idx = self.selected_polygon_idx
+        if idx is not None and 0 <= idx < len(self.polygon_one_way):
+            self.polygon_one_way[idx] = not self.polygon_one_way[idx]
+            if self.on_polygon_modified:
+                self.on_polygon_modified(idx)
     
+    def _get_interior_angle(
+        self, polygon: List[Tuple[float, float]], idx: int
+    ) -> float:
+        """Compute interior angle (degrees) at polygon vertex idx."""
+        n = len(polygon)
+        if n < 3:
+            return 0.0
+        prev = polygon[(idx - 1) % n]
+        curr = polygon[idx]
+        nxt = polygon[(idx + 1) % n]
+        v1 = (prev[0] - curr[0], prev[1] - curr[1])
+        v2 = (nxt[0] - curr[0], nxt[1] - curr[1])
+        dot = v1[0] * v2[0] + v1[1] * v2[1]
+        mag1 = math.hypot(v1[0], v1[1])
+        mag2 = math.hypot(v2[0], v2[1])
+        if mag1 < 0.001 or mag2 < 0.001:
+            return 0.0
+        cos_a = max(-1.0, min(1.0, dot / (mag1 * mag2)))
+        return math.degrees(math.acos(cos_a))
+
+    def _draw_angle_hint(
+        self,
+        screen: pygame.Surface,
+        screen_pos: Tuple[int, int],
+        angle_deg: float,
+    ) -> None:
+        """Draw a small arc + angle text at a vertex."""
+        if angle_deg <= 0.5 or angle_deg >= 179.5:
+            return
+        arc_radius = 14
+        segments = max(4, int(angle_deg / 10))
+        angle_rad = math.radians(angle_deg)
+        pts = [screen_pos]
+        for i in range(segments + 1):
+            t = -angle_rad * i / segments
+            pts.append((
+                screen_pos[0] + arc_radius * math.cos(t),
+                screen_pos[1] + arc_radius * math.sin(t),
+            ))
+        if len(pts) >= 3:
+            wedge = pygame.Surface(self.rect.size, pygame.SRCALPHA)
+            pygame.draw.polygon(wedge, (*_COLORS["polygon_fill"], 60), pts)
+            screen.blit(wedge, self.rect.topleft)
+        label = self._font_sm.render(f"{angle_deg:.0f}°", True, _COLORS["text"])
+        label_x = screen_pos[0] + 10
+        label_y = screen_pos[1] - label.get_height() - 4
+        bg = pygame.Surface((label.get_width() + 4, label.get_height() + 2), pygame.SRCALPHA)
+        bg.fill((0, 0, 0, 180))
+        screen.blit(bg, (label_x - 2, label_y - 1))
+        screen.blit(label, (label_x, label_y))
+
     def clear_all(self) -> None:
         """Clear all polygons"""
         self.polygons = []
@@ -488,23 +548,26 @@ class CollisionPainter:
         
         # Keyboard shortcuts
         if event.type == pygame.KEYDOWN:
+            mods = pygame.key.get_mods()
+            ctrl = mods & (pygame.KMOD_LCTRL | pygame.KMOD_LMETA)
+
             # Track Shift state for edge draw
             if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
                 self._shift_held = True
-            
-            # E - toggle edge draw mode
-            elif event.key == pygame.K_e:
+
+            # Ctrl+E - toggle edge draw mode
+            elif ctrl and event.key == pygame.K_e:
                 self.edge_draw_mode = not self.edge_draw_mode
                 if not self.edge_draw_mode:
                     self._edge_start = None
                 return True
-            
+
             # Enter - complete polygon
             elif event.key in (pygame.K_RETURN, pygame.K_KP_ENTER):
                 if len(self.current_polygon) >= 3:
                     self._complete_polygon()
                     return True
-            
+
             # Escape - cancel current polygon or deselect or close help
             elif event.key == pygame.K_ESCAPE:
                 if self.show_help:
@@ -517,44 +580,45 @@ class CollisionPainter:
                     self.selected_polygon_idx = None
                     self.selected_vertex_idx = None
                     return True
-            
-            # Delete - remove selected polygon
+
+            # Delete/Backspace - remove selected polygon or last vertex
             elif event.key in (pygame.K_DELETE, pygame.K_BACKSPACE):
                 if self.selected_polygon_idx is not None:
                     self._delete_polygon(self.selected_polygon_idx)
                     return True
                 elif self.current_polygon:
-                    # Remove last vertex
                     self.current_polygon.pop()
                     return True
-            
-            # G - toggle grid
-            elif event.key == pygame.K_g:
+
+            # Ctrl+G - toggle grid
+            elif ctrl and event.key == pygame.K_g:
                 self.show_grid = not self.show_grid
                 return True
-            
-            # S - toggle snap (only if Ctrl is not held)
-            elif event.key == pygame.K_s:
-                mods = pygame.key.get_mods()
-                ctrl_held = mods & (pygame.KMOD_CTRL | pygame.KMOD_LMETA)
-                if not ctrl_held:
-                    self.snap_to_grid = not self.snap_to_grid
-                    return True
-            
-            # O - toggle one-way collision for selected polygon
-            elif event.key == pygame.K_o:
+
+            # Ctrl+Shift+S - toggle snap (Ctrl+S reserved for save)
+            elif ctrl and event.key == pygame.K_s and (mods & pygame.KMOD_SHIFT):
+                self.snap_to_grid = not self.snap_to_grid
+                return True
+
+            # Ctrl+O - toggle one-way collision for selected polygon
+            elif ctrl and event.key == pygame.K_o:
                 if self.selected_polygon_idx is not None:
                     idx = self.selected_polygon_idx
                     self.polygon_one_way[idx] = not self.polygon_one_way[idx]
                     if self.on_polygon_modified:
                         self.on_polygon_modified(idx)
                     return True
-            
-            # R - reset view
-            elif event.key == pygame.K_r:
+
+            # Ctrl+R - reset view
+            elif ctrl and event.key == pygame.K_r:
                 self._center_view()
                 self.zoom = 2.0
                 return True
+
+            # Ctrl+A - toggle angle hints
+            elif ctrl and event.key == pygame.K_a:
+                self.show_angle_hints = not self.show_angle_hints
+                return True
         
         if event.type == pygame.KEYUP:
             if event.key in (pygame.K_LSHIFT, pygame.K_RSHIFT):
@@ -744,20 +808,21 @@ class CollisionPainter:
                 ("Right-click / Enter", "Complete polygon"),
                 ("Escape", "Cancel current polygon"),
                 ("Shift (edge mode)", "Constrain to axis"),
-                ("E", "Toggle edge draw mode"),
+                ("Ctrl+E", "Toggle edge draw mode"),
             ]),
             ("SELECTION", [
                 ("Left-click polygon", "Select polygon"),
                 ("Left-click vertex", "Select & drag vertex"),
                 ("Delete / Backspace", "Remove selected polygon"),
-                ("O", "Toggle one-way collision"),
+                ("Ctrl+O", "Toggle one-way collision"),
             ]),
             ("VIEW", [
                 ("Mouse wheel", "Zoom in/out"),
                 ("Middle mouse / Space+LMB", "Pan view"),
-                ("G", "Toggle grid"),
-                ("S", "Toggle snap to grid"),
-                ("R", "Reset view"),
+                ("Ctrl+G", "Toggle grid"),
+                ("Ctrl+Shift+S", "Toggle snap to grid"),
+                ("Ctrl+R", "Reset view"),
+                ("Ctrl+A", "Toggle angle hints"),
             ]),
             ("MISC", [
                 ("Info button (top-right)", "Toggle this help panel"),
@@ -905,6 +970,24 @@ class CollisionPainter:
             radius = VERTEX_HOVER_RADIUS if is_hovered_vertex else VERTEX_RADIUS
             pygame.draw.circle(screen, color, (px, py), radius)
             pygame.draw.circle(screen, (0, 0, 0), (px, py), radius, 1)
+
+        # One-way badge on selected polygon
+        if selected and one_way and len(polygon) >= 3:
+            cx = int(sum(p[0] for p in screen_points) / len(screen_points))
+            cy = int(sum(p[1] for p in screen_points) / len(screen_points))
+            badge = self._font_sm.render("ONE-WAY", True, (255, 255, 255))
+            bx = cx - badge.get_width() // 2
+            by = cy - badge.get_height() // 2
+            bg = pygame.Surface((badge.get_width() + 8, badge.get_height() + 4), pygame.SRCALPHA)
+            bg.fill((_COLORS["one_way"][0], _COLORS["one_way"][1], _COLORS["one_way"][2], 200))
+            screen.blit(bg, (bx - 4, by - 2))
+            screen.blit(badge, (bx, by))
+
+        # Angle hints
+        if self.show_angle_hints:
+            for i, (px, py) in enumerate(screen_points):
+                angle = self._get_interior_angle(polygon, i)
+                self._draw_angle_hint(screen, (px, py), angle)
     
     def _draw_current_polygon(self, screen: pygame.Surface) -> None:
         """Draw the polygon currently being drawn"""
@@ -934,6 +1017,25 @@ class CollisionPainter:
             radius = VERTEX_HOVER_RADIUS if is_first else VERTEX_RADIUS
             pygame.draw.circle(screen, color, (px, py), radius)
             pygame.draw.circle(screen, (0, 0, 0), (px, py), radius, 1)
+
+        # Angle hints for vertices with both neighbors
+        if self.show_angle_hints and len(self.current_polygon) >= 3:
+            for i, (px, py) in enumerate(screen_points):
+                if i == 0 or i == len(screen_points) - 1:
+                    continue
+                poly = self.current_polygon
+                prev = poly[i - 1]
+                curr = poly[i]
+                nxt = poly[i + 1]
+                v1 = (prev[0] - curr[0], prev[1] - curr[1])
+                v2 = (nxt[0] - curr[0], nxt[1] - curr[1])
+                dot = v1[0] * v2[0] + v1[1] * v2[1]
+                mag1 = math.hypot(v1[0], v1[1])
+                mag2 = math.hypot(v2[0], v2[1])
+                if mag1 > 0.001 and mag2 > 0.001:
+                    cos_a = max(-1.0, min(1.0, dot / (mag1 * mag2)))
+                    angle = math.degrees(math.acos(cos_a))
+                    self._draw_angle_hint(screen, (px, py), angle)
     
     def _draw_status(self, screen: pygame.Surface) -> None:
         """Draw status text"""
@@ -949,12 +1051,13 @@ class CollisionPainter:
             one_way = self.polygon_one_way[self.selected_polygon_idx]
             one_way_str = " (ONE-WAY)" if one_way else ""
             lines.append(f"Selected polygon {self.selected_polygon_idx}{one_way_str}")
-            lines.append("Delete to remove, O to toggle one-way")
+            lines.append("Delete to remove, Ctrl+O to toggle one-way")
         else:
             lines.append("Click to add vertices, right-click to complete")
         
-        lines.append(f"Zoom: {self.zoom:.1f}x | Grid: {'ON' if self.show_grid else 'OFF'} (G) | Snap: {'ON' if self.snap_to_grid else 'OFF'} (S)")
-        lines.append(f"Polygons: {len(self.polygons)} | R: reset view")
+        snap_str = f"Snap: {'ON' if self.snap_to_grid else 'OFF'} (Ctrl+Shift+S)"
+        lines.append(f"Zoom: {self.zoom:.1f}x | Grid: {'ON' if self.show_grid else 'OFF'} (Ctrl+G) | {snap_str}")
+        lines.append(f"Polygons: {len(self.polygons)} | Ctrl+R: reset | Ctrl+A: angle hints {'ON' if self.show_angle_hints else 'OFF'}")
         
         y = self.rect.y + 5
         for line in lines: