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

{tilemap_editor-3.3.8/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.8
+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.8 → tilemap_editor-3.3.10}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-editor"
-version = "3.3.8"
+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.8 → 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.8 → tilemap_editor-3.3.10}/src/tilemap_editor/cli.py

@@ -5,7 +5,7 @@ import sys
 
 from editor import Editor
 from utils import error_handler, error_context
-from .settings import init_settings
+from .settings import init_settings, update_settings
 
 
 def _parse_size(text: str) -> tuple[int, int]:
@@ -29,6 +29,12 @@ def main() -> None:
         help="Also create src/main.py boilerplate"
     )
 
+    update_parser = subparsers.add_parser("update", help="Update settings.json base_path for current device")
+    update_parser.add_argument(
+        "--path", default=None,
+        help="Explicit base path (default: resolves cwd to absolute path)"
+    )
+
     run_parser = subparsers.add_parser("run", help="Run the tilemap editor")
     run_parser.add_argument(
         "--size", default="1500x900", help="Window size as WIDTHxHEIGHT"
@@ -43,6 +49,10 @@ def main() -> None:
         init_settings(generate_main=args.with_main)
         return
 
+    if args.command == "update":
+        update_settings(path=args.path)
+        return
+
     if args.command is None or args.command == "run":
         _run_editor(args)
         return

{tilemap_editor-3.3.8 → tilemap_editor-3.3.10}/src/tilemap_editor/settings.py

@@ -1,6 +1,7 @@
 import json
 import sys
 from pathlib import Path
+from typing import Optional
 
 
 def init_settings(generate_main: bool = False) -> None:
@@ -71,4 +72,37 @@ if __name__ == "__main__":
     with open(main_file, "w") as f:
         f.write(boilerplate)
 
-    print(f"Created {main_file}")
+    print(f"Created {main_file}")
+
+
+def update_settings(path: Optional[str] = None) -> None:
+    """Update base_path in an existing settings.json to the current device path.
+
+    If no path is given, resolves the current working directory to an absolute
+    path and writes it as base_path. This makes settings.json portable when
+    shared across devices — run update on each device to fix the path.
+
+    Args:
+        path: Optional explicit base_path to write (e.g. --path /home/user/project)
+    """
+    settings_file = Path.cwd() / "settings.json"
+
+    if not settings_file.exists():
+        raise RuntimeError(
+            "settings.json not found. Run 'tilemap-editor init' first."
+        )
+
+    with open(settings_file, "r") as f:
+        config = json.load(f)
+
+    if path is not None:
+        new_base = str(Path(path).expanduser().resolve())
+    else:
+        new_base = str(Path.cwd().resolve())
+
+    config["base_path"] = new_base
+
+    with open(settings_file, "w") as f:
+        json.dump(config, f, indent=4)
+
+    print(f"Updated base_path to '{new_base}' in {settings_file}")

{tilemap_editor-3.3.8 → 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.8
+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.8 → 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.8 → 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.8 → 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":

{tilemap_editor-3.3.8 → tilemap_editor-3.3.10}/tests/test_project_paths.py

@@ -10,7 +10,7 @@ import sys
 sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
 
 from utils.project_paths import to_project_path, resolve_project_path
-from tilemap_editor.settings import init_settings
+from tilemap_editor.settings import init_settings, update_settings
 
 
 @pytest.fixture
@@ -143,3 +143,83 @@ class TestInitSettings:
                 assert src_main.exists()
             finally:
                 os.chdir(str(orig_cwd))
+
+
+class TestUpdateSettings:
+    def test_updates_base_path_to_cwd_when_no_path_given(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp).resolve()
+            orig_cwd = Path.cwd()
+            os.chdir(str(tmp_path))
+            try:
+                settings_file = tmp_path / "settings.json"
+                with open(settings_file, "w") as f:
+                    json.dump({"base_path": "/old/path", "data_path": "data"}, f)
+
+                update_settings()
+
+                with open(settings_file) as f:
+                    cfg = json.load(f)
+                assert cfg["base_path"] == str(tmp_path)
+                assert cfg["data_path"] == "data"
+            finally:
+                os.chdir(str(orig_cwd))
+
+    def test_updates_base_path_to_given_path(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp).resolve()
+            orig_cwd = Path.cwd()
+            os.chdir(str(tmp_path))
+            try:
+                settings_file = tmp_path / "settings.json"
+                with open(settings_file, "w") as f:
+                    json.dump({"base_path": "/old/path", "data_path": "data"}, f)
+
+                new_path = tmp_path / "some" / "other"
+                update_settings(path=str(new_path))
+
+                with open(settings_file) as f:
+                    cfg = json.load(f)
+                assert cfg["base_path"] == str(new_path.resolve())
+            finally:
+                os.chdir(str(orig_cwd))
+
+    def test_raises_when_settings_json_missing(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp).resolve()
+            orig_cwd = Path.cwd()
+            os.chdir(str(tmp_path))
+            try:
+                with pytest.raises(RuntimeError, match="settings.json not found"):
+                    update_settings()
+            finally:
+                os.chdir(str(orig_cwd))
+
+    def test_does_not_touch_other_fields(self):
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp).resolve()
+            orig_cwd = Path.cwd()
+            os.chdir(str(tmp_path))
+            try:
+                original = {
+                    "base_path": "/old/path",
+                    "data_path": "data",
+                    "collision_paths": {"tileset": "collision"},
+                    "nodes_path": "nodes",
+                    "error_handler": {"log_path": "errors.log"},
+                }
+                settings_file = tmp_path / "settings.json"
+                with open(settings_file, "w") as f:
+                    json.dump(original, f)
+
+                update_settings()
+
+                with open(settings_file) as f:
+                    cfg = json.load(f)
+                assert cfg["base_path"] == str(tmp_path)
+                assert cfg["data_path"] == "data"
+                assert cfg["collision_paths"] == {"tileset": "collision"}
+                assert cfg["nodes_path"] == "nodes"
+                assert cfg["error_handler"] == {"log_path": "errors.log"}
+            finally:
+                os.chdir(str(orig_cwd))