tilemap-editor 3.3.9__tar.gz → 3.3.10__tar.gz

{tilemap_editor-3.3.9/src/tilemap_editor.egg-info → tilemap_editor-3.3.10}/PKG-INFO

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

{tilemap_editor-3.3.9 → tilemap_editor-3.3.10}/pyproject.toml

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

{tilemap_editor-3.3.9 → tilemap_editor-3.3.10}/src/editor.py

@@ -158,6 +158,7 @@ class Editor:
         self.eraser_mode = False
         self.select_mode = False
         self.node_editing_mode = False
+        self.show_nodes = False
         self._prev_tool = None
 
         if isinstance(size, tuple) and len(size) == 2:
@@ -1191,6 +1192,14 @@ class Editor:
                 elif event.key == pygame.K_y and (ctrl_held or meta_held):
                     self.tilemap.redo()
                     continue
+                elif event.key == pygame.K_n and (ctrl_held or meta_held) and shift_held:
+                    self.node_editing_mode = not self.node_editing_mode
+                    if self.node_editing_mode:
+                        self.show_nodes = False
+                        self.pan_mode = False
+                        self.select_mode = False
+                        self.eraser_mode = False
+                    continue
                 elif event.key == pygame.K_n and (ctrl_held or meta_held):
                     self.open_map_setup()
                     continue
@@ -1241,16 +1250,16 @@ class Editor:
                             self.tilemap.layer_manager.set_active_layer(idx)
                         continue
 
-            # Priority 5: Toolbar
-            if self.toolbar and self.toolbar.handle_event(event):
-                continue
-
-            # Priority 5.5: Node selector & editor (when node mode active)
+            # Priority 5: Node selector & editor (float on top, check events first)
             if self.node_selector and self.node_selector.handle_event(event):
                 continue
             if self.node_editor and self.node_editor.handle_event(event):
                 continue
 
+            # Priority 5.5: Toolbar
+            if self.toolbar and self.toolbar.handle_event(event):
+                continue
+
             # Priority 6: Dockable animation panel
             if self.left_panel_visible and self.animation_panel:
                 if hasattr(self.animation_panel, "handle_event"):

{tilemap_editor-3.3.9 → tilemap_editor-3.3.10/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.3.9 → tilemap_editor-3.3.10}/src/widgets/tile_grid.py

@@ -181,6 +181,10 @@ class TileGrid:
         if self.editor.node_editing_mode:
             return self._handle_node_event(event)
 
+        if self.editor.show_nodes:
+            if self._handle_show_node_event(event):
+                return True
+
         mouse_pos = pygame.mouse.get_pos()
         is_hovering = self.rect.collidepoint(mouse_pos)
         if event.type == pygame.KEYDOWN:
@@ -1502,6 +1506,7 @@ class TileGrid:
             return
 
         editing = self.editor.node_editing_mode
+        showing = self.editor.show_nodes
 
         node_type_colors = {
             "area": (80, 220, 120),       # Green / Emerald
@@ -1513,7 +1518,8 @@ class TileGrid:
             "particle_emitter": (240, 140, 200),  # Pink / Magenta
         }
 
-        active = nm.get_active_node() if editing else None
+        visible = editing or showing
+        active = nm.get_active_node() if visible else None
         for node in nm.nodes.values():
             sx, sy = self._node_to_screen(node.area.x, node.area.y)
             sw, sh = self._node_screen_size(node.area.w, node.area.h)
@@ -1521,8 +1527,13 @@ class TileGrid:
             if not self.rect.colliderect(Rect(sx, sy, sw, sh)):
                 continue
 
-            is_active = editing and active is not None and active.node_id == node.node_id
-            alpha = 180 if is_active else (80 if editing else 40)
+            is_active = visible and active is not None and active.node_id == node.node_id
+            if editing:
+                alpha = 180 if is_active else 80
+            elif showing:
+                alpha = 140 if is_active else 70
+            else:
+                alpha = 40
             
             color = node_type_colors.get(node.node_type, (80, 220, 120))
 
@@ -1533,14 +1544,14 @@ class TileGrid:
             border_color = (*color, alpha)
             pygame.draw.rect(screen, border_color, Rect(sx, sy, sw, sh), max(1, int(2 * self.zoom_level)))
 
-            if editing:
+            if visible:
                 label = self.font_status.render(node.name, True, (255, 255, 255))
                 label_bg = pygame.Surface((label.get_width() + 4, label.get_height() + 2), pygame.SRCALPHA)
                 label_bg.fill((0, 0, 0, 160))
                 screen.blit(label_bg, (sx, sy - label.get_height() - 2))
                 screen.blit(label, (sx + 2, sy - label.get_height() - 1))
 
-            if is_active:
+            if is_active and editing:
                 self._draw_node_handles(screen, Rect(sx, sy, sw, sh), color)
 
         self._draw_particle_previews(screen)
@@ -1563,8 +1574,8 @@ class TileGrid:
             if active_id not in self._particle_previews:
                 self._particle_previews[active_id] = ParticlePreview(dict(active.properties))
             preview = self._particle_previews[active_id]
-            preview.config = active.properties
-            preview.update(dt, active.area.x, active.area.y, active.area.w, active.area.h)
+            rs = self.editor.tilemap.render_scale
+            preview.update(dt, active.area.x, active.area.y, active.area.w * rs, active.area.h * rs)
             self._last_active_node_id = active_id
         else:
             self._particle_previews.clear()
@@ -1630,6 +1641,72 @@ class TileGrid:
                 return name
         return None
 
+    def _handle_show_node_event(self, event) -> bool:
+        nm = getattr(self.editor, "node_manager", None)
+        if not nm or not nm.nodes:
+            return False
+
+        mouse_pos = pygame.mouse.get_pos()
+        is_hover = self.rect.collidepoint(mouse_pos)
+
+        if event.type == pygame.MOUSEBUTTONDOWN:
+            if event.button == 1 and is_hover:
+                wx, wy = self.screen_to_world(mouse_pos)
+                active = nm.get_active_node()
+
+                if active:
+                    sw, sh = self._node_screen_size(active.area.w, active.area.h)
+                    sx, sy = self._node_to_screen(active.area.x, active.area.y)
+                    if Rect(sx, sy, sw, sh).collidepoint(mouse_pos):
+                        self._node_drag_state = "moving"
+                        self._node_drag_start = (wx, wy)
+                        self._node_original_rect = NodeRect(
+                            active.area.x, active.area.y,
+                            active.area.w, active.area.h,
+                        )
+                        return True
+
+                    for node in nm.nodes.values():
+                        if node.node_id == active.node_id:
+                            continue
+                        nsx, nsy = self._node_to_screen(node.area.x, node.area.y)
+                        nsw, nsh = self._node_screen_size(node.area.w, node.area.h)
+                        if Rect(nsx, nsy, nsw, nsh).collidepoint(mouse_pos):
+                            nm.set_active_node(node.node_id)
+                            return True
+                else:
+                    for node in nm.nodes.values():
+                        nsx, nsy = self._node_to_screen(node.area.x, node.area.y)
+                        nsw, nsh = self._node_screen_size(node.area.w, node.area.h)
+                        if Rect(nsx, nsy, nsw, nsh).collidepoint(mouse_pos):
+                            nm.set_active_node(node.node_id)
+                            return True
+
+                    nm.set_active_node(None)
+                return False
+
+        elif event.type == pygame.MOUSEBUTTONUP:
+            if event.button == 1 and self._node_drag_state is not None:
+                self._node_drag_state = None
+                self._node_drag_handle = None
+                self._node_original_rect = None
+                return True
+
+        elif event.type == pygame.MOUSEMOTION:
+            if self._node_drag_state is not None and is_hover:
+                active = nm.get_active_node()
+                if active and self._node_original_rect:
+                    orig = self._node_original_rect
+                    wx, wy = self.screen_to_world(mouse_pos)
+                    dx = wx - self._node_drag_start[0]
+                    dy = wy - self._node_drag_start[1]
+                    if self._node_drag_state == "moving":
+                        active.area.x = orig.x + dx
+                        active.area.y = orig.y + dy
+                return True
+
+        return False
+
     def _handle_node_event(self, event) -> bool:
         nm = getattr(self.editor, "node_manager", None)
         if not nm:

{tilemap_editor-3.3.9 → tilemap_editor-3.3.10}/src/widgets/ui/node_editor.py

@@ -56,14 +56,30 @@ class NodeEditor:
         screen_h = self.editor.screen.get_height()
         panel_w = self.rect.width
         panel_h = self.rect.height
-        px = sx + sw + 8
-        py = sy + sh + 8
-        if px + panel_w > screen_w - 10:
-            px = max(10, sx - panel_w - 8)
-        if py + panel_h > screen_h - 10:
-            py = max(10, sy - panel_h - 8)
-        self.rect.x = max(10, min(px, screen_w - panel_w - 10))
-        self.rect.y = max(10, min(py, screen_h - panel_h - 10))
+        pad = 24
+
+        node_rect = Rect(sx, sy, sw, sh)
+        positions = [
+            (sx + sw + pad, sy),
+            (sx - panel_w - pad, sy),
+            (sx, sy + sh + pad),
+            (sx, sy - panel_h - pad),
+        ]
+        best = None
+        for px, py in positions:
+            px = max(10, min(px, screen_w - panel_w - 10))
+            py = max(10, min(py, screen_h - panel_h - 10))
+            pr = Rect(px, py, panel_w, panel_h)
+            if not pr.colliderect(node_rect):
+                best = (px, py)
+                break
+        if best is None:
+            px = max(10, min(sx + sw + pad, screen_w - panel_w - 10))
+            py = max(10, min(sy, screen_h - panel_h - 10))
+            self.rect.x = px
+            self.rect.y = py
+        else:
+            self.rect.x, self.rect.y = best
 
     @property
     def editing_field(self) -> bool:

{tilemap_editor-3.3.9 → tilemap_editor-3.3.10}/src/widgets/ui/toolbar.py

@@ -70,11 +70,9 @@ class Toolbar:
                     elif key == "auto":
                         self.editor.toggle_auto_autotile()
                     elif key == "nodes":
-                        self.editor.node_editing_mode = not self.editor.node_editing_mode
-                        if self.editor.node_editing_mode:
-                            self.editor.pan_mode = False
-                            self.editor.select_mode = False
-                            self.editor.eraser_mode = False
+                        self.editor.show_nodes = not self.editor.show_nodes
+                        if self.editor.show_nodes:
+                            self.editor.node_editing_mode = False
                     elif key == "zoom_in":
                         if self.editor.tile_grid_widget:
                             self.editor.tile_grid_widget.zoom_by(0.1)
@@ -98,6 +96,7 @@ class Toolbar:
 
         for key, (r, label) in self.buttons.items():
             is_active = False
+            is_show = False
             if key == "pan":
                 is_active = self.editor.pan_mode
             elif key == "select":
@@ -112,14 +111,18 @@ class Toolbar:
             elif key == "auto":
                 is_active = self.editor.autotile_mode
             elif key == "nodes":
-                is_active = self.editor.node_editing_mode
+                is_active = self.editor.show_nodes
+                is_show = False
 
             hover = r.collidepoint(mouse_pos)
-            bg = (
-                COLORS.accent_active
-                if is_active
-                else (COLORS.hover if hover else COLORS.panel_alt)
-            )
+            if is_active:
+                bg = COLORS.accent_active
+            elif is_show:
+                bg = COLORS.selected
+            elif hover:
+                bg = COLORS.hover
+            else:
+                bg = COLORS.panel_alt
             pygame.draw.rect(screen, bg, r, border_radius=SHAPE.radius_sm)
             pygame.draw.rect(
                 screen, COLORS.border_soft, r, 1, border_radius=SHAPE.radius_sm
@@ -146,7 +149,7 @@ class Toolbar:
                 elif key == "auto":
                     tip = "Auto-Autotile"
                 elif key == "nodes":
-                    tip = "Node Mode (Ctrl+Shift+N)"
+                    tip = "Show Nodes (Ctrl+Shift+N for Edit mode)" if not self.editor.show_nodes else "Hide Nodes"
                 elif key == "zoom_in":
                     tip = "Zoom In (Ctrl+Wheel)"
                 elif key == "zoom_out":