tilemap-editor 3.2.7__tar.gz → 3.2.9__tar.gz

{tilemap_editor-3.2.7/src/tilemap_editor.egg-info → tilemap_editor-3.2.9}/PKG-INFO

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

{tilemap_editor-3.2.7 → tilemap_editor-3.2.9}/pyproject.toml

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

{tilemap_editor-3.2.7 → tilemap_editor-3.2.9}/src/editor.py

@@ -31,6 +31,8 @@ from widgets.ui.confirm_dialog import ConfirmDialog
 from widgets.ui.layer_type_dialog import LayerTypeDialog
 from widgets.ui.menubar import MenuBar
 from widgets.ui.toolbar import Toolbar
+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.tooltip import TooltipManager
@@ -38,6 +40,7 @@ from widgets.ui.theme import get_theme_manager, set_theme, THEMES
 from utils.log_capture import setup_console_log
 from utils.standalone import launch_standalone
 from utils import error_handler, error_context
+from node_manager import NodeManager
 
 if TYPE_CHECKING:
     from plugins.sprite_animation import SpriteAnimationEditor
@@ -153,6 +156,7 @@ class Editor:
         self.autotile_mode = False
         self.eraser_mode = False
         self.select_mode = False
+        self.node_editing_mode = False
         self._prev_tool = None
 
         if isinstance(size, tuple) and len(size) == 2:
@@ -240,6 +244,9 @@ class Editor:
         self.map_setup_widget = MapSetup(self, Rect(center_x, center_y, 400, 400))
         self.map_setup_widget.visible = False
         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)
 
     def open_file_manager(
         self,
@@ -1126,7 +1133,7 @@ class Editor:
                 elif event.key == pygame.K_o and (ctrl_held or meta_held):
                     self.perform_load()
                     continue
-                elif event.key == pygame.K_SPACE:
+                elif event.key == pygame.K_SPACE and (ctrl_held or meta_held):
                     if self.pan_mode:
                         # Restoring: turn off pan, re-enable previous tool
                         self.pan_mode = False
@@ -1134,17 +1141,22 @@ class Editor:
                             self.select_mode = True
                         elif getattr(self, "_prev_tool", None) == "eraser":
                             self.eraser_mode = True
+                        elif getattr(self, "_prev_tool", None) == "nodes":
+                            self.node_editing_mode = True
                     else:
                         # Entering pan: save current tool, turn off others
                         if self.select_mode:
                             self._prev_tool = "select"
                         elif self.eraser_mode:
                             self._prev_tool = "eraser"
+                        elif self.node_editing_mode:
+                            self._prev_tool = "nodes"
                         else:
                             self._prev_tool = None
                         self.pan_mode = True
                         self.select_mode = False
                         self.eraser_mode = False
+                        self.node_editing_mode = False
                     continue
                 elif event.mod & pygame.KMOD_CTRL and event.key == pygame.K_g:
                     self.toggle_grid()
@@ -1156,15 +1168,22 @@ class Editor:
                     self.toggle_animation_panel()
                     continue
                 elif pygame.K_1 <= event.key <= pygame.K_9:
-                    idx = event.key - pygame.K_1
-                    if idx < self.tilemap.layer_manager.get_layer_count():
-                        self.tilemap.layer_manager.set_active_layer(idx)
-                    continue
+                    if not (self.node_editor and self.node_editor.visible and self.node_editor.editing_field):
+                        idx = event.key - pygame.K_1
+                        if idx < self.tilemap.layer_manager.get_layer_count():
+                            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)
+            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 6: Dockable animation panel
             if self.left_panel_visible and self.animation_panel:
                 if hasattr(self.animation_panel, "handle_event"):
@@ -1303,6 +1322,10 @@ class Editor:
 
             if self.toolbar:
                 self.toolbar.draw(self.screen)
+            if self.node_selector:
+                self.node_selector.draw(self.screen)
+            if self.node_editor:
+                self.node_editor.draw(self.screen)
             self.menubar.draw(self.screen)
             self.tooltip.draw(self.screen)
 

tilemap_editor-3.2.9/src/node_manager.py

@@ -0,0 +1,147 @@
+import json
+import uuid
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+
+from nodes import Node, NodeRect
+
+if TYPE_CHECKING:
+    from editor import Editor
+
+
+def create_node_id() -> str:
+    return str(uuid.uuid4())
+
+
+SIDECAR_VERSION = 1
+
+
+class NodeManager:
+    def __init__(self, editor: "Editor") -> None:
+        self.editor = editor
+        self.nodes: Dict[str, Node] = {}
+        self.active_node_id: Optional[str] = None
+        self.active_group_name: Optional[str] = None
+        self.groups: List[str] = []
+        self.default_node_type: str = "area"
+        self._nodes_dir: Optional[Path] = None
+
+    @property
+    def nodes_dir(self) -> Path:
+        if self._nodes_dir is None:
+            config = getattr(self.editor, "config", {})
+            rel = config.get("nodes_path", "nodes")
+            self._nodes_dir = self.editor.data_root / rel
+        return self._nodes_dir
+
+    def _sidecar_path_for(self, map_path: Path) -> Path:
+        return self.nodes_dir / f"{map_path.stem}.nodes.json"
+
+    def load(self, map_path: Path) -> None:
+        self.nodes.clear()
+        self.groups.clear()
+        self.active_node_id = None
+        self.active_group_name = None
+        sidecar = self._sidecar_path_for(map_path)
+        if not sidecar.is_file():
+            return
+        try:
+            raw = json.loads(sidecar.read_text(encoding="utf-8"))
+            if not isinstance(raw, dict):
+                return
+            self.groups = list(raw.get("groups", []))
+            for item in raw.get("nodes", []):
+                if isinstance(item, dict):
+                    node = Node.from_dict(item)
+                    self.nodes[node.node_id] = node
+        except (json.JSONDecodeError, KeyError, ValueError, TypeError):
+            import logging
+            logging.warning(f"Failed to load nodes from {sidecar}")
+
+    def save(self, map_path: Path) -> None:
+        sidecar = self._sidecar_path_for(map_path)
+        self.nodes_dir.mkdir(parents=True, exist_ok=True)
+        data: Dict[str, Any] = {
+            "version": SIDECAR_VERSION,
+            "groups": self.groups,
+            "nodes": [node.to_dict() for node in self.nodes.values()],
+        }
+        sidecar.write_text(json.dumps(data, indent=2), encoding="utf-8")
+
+    def add_node(self, node: Node) -> str:
+        self.nodes[node.node_id] = node
+        return node.node_id
+
+    def remove_node(self, node_id: str) -> None:
+        self.nodes.pop(node_id, None)
+        if self.active_node_id == node_id:
+            self.active_node_id = None
+
+    def get_node(self, node_id: str) -> Optional[Node]:
+        return self.nodes.get(node_id)
+
+    def get_active_node(self) -> Optional[Node]:
+        if self.active_node_id is None:
+            return None
+        return self.nodes.get(self.active_node_id)
+
+    def set_active_node(self, node_id: Optional[str]) -> None:
+        self.active_node_id = node_id
+        if node_id is not None:
+            self.active_group_name = None
+
+    def set_active_group(self, group_name: Optional[str]) -> None:
+        self.active_group_name = group_name
+        if group_name is not None:
+            self.active_node_id = None
+
+    def get_nodes_for_layer(self, layer_name: str) -> List[Node]:
+        return [n for n in self.nodes.values() if n.layer_name == layer_name]
+
+    def create_default_node(self, layer_name: str, node_type: str = "area") -> Node:
+        count = len(self.nodes) + 1
+        return Node(
+            node_id=create_node_id(),
+            name=f"{node_type.capitalize()} {count}",
+            node_type=node_type,
+            area=NodeRect(x=0, y=0, w=64, h=64),
+            layer_name=layer_name,
+        )
+
+    def rename_group(self, old_name: str, new_name: str) -> bool:
+        if not new_name or new_name == old_name:
+            return False
+        if new_name in self.groups:
+            return False  # Already exists
+        if old_name not in self.groups:
+            return False
+            
+        # Update groups list
+        idx = self.groups.index(old_name)
+        self.groups[idx] = new_name
+        
+        # Update child nodes
+        for node in self.nodes.values():
+            if node.group == old_name:
+                node.group = new_name
+                
+        if self.active_group_name == old_name:
+            self.active_group_name = new_name
+        return True
+
+    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
+        node = self.nodes[node_id]
+        keys = list(self.nodes.keys())
+        keys.remove(node_id)
+        target_idx = keys.index(target_node_id)
+        if not before:
+            target_idx += 1
+        keys.insert(target_idx, node_id)
+        
+        # Rebuild dictionary
+        new_nodes = {}
+        for k in keys:
+            new_nodes[k] = self.nodes[k]
+        self.nodes = new_nodes

tilemap_editor-3.2.9/src/nodes.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+
+@dataclass
+class NodeRect:
+    x: int
+    y: int
+    w: int
+    h: int
+
+    def to_dict(self) -> Dict[str, int]:
+        return {"x": self.x, "y": self.y, "w": self.w, "h": self.h}
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "NodeRect":
+        return cls(x=int(data["x"]), y=int(data["y"]), w=int(data["w"]), h=int(data["h"]))
+
+
+@dataclass
+class Node:
+    node_id: str
+    name: str
+    node_type: str
+    area: NodeRect
+    layer_name: str
+    properties: Dict[str, Any] = field(default_factory=dict)
+    group: Optional[str] = None
+
+    def to_dict(self) -> Dict[str, Any]:
+        return {
+            "node_id": self.node_id,
+            "name": self.name,
+            "node_type": self.node_type,
+            "area": self.area.to_dict(),
+            "layer_name": self.layer_name,
+            "properties": dict(self.properties),
+            "group": self.group,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "Node":
+        return cls(
+            node_id=str(data["node_id"]),
+            name=str(data["name"]),
+            node_type=str(data.get("node_type", "area")),
+            area=NodeRect.from_dict(data["area"]),
+            layer_name=str(data.get("layer_name", "")),
+            properties=dict(data.get("properties", {})),
+            group=data.get("group"),
+        )

{tilemap_editor-3.2.7 → tilemap_editor-3.2.9}/src/tilemap.py

@@ -298,6 +298,8 @@ class Tilemap:
                     ts_data["tile_properties"] = {
                         str(k): v for k, v in ts.tile_properties.items()
                     }
+                if ts.animation:
+                    ts_data["animation"] = ts.animation
 
                 save_data["resources"]["tilesets"].append(ts_data)
 
@@ -394,6 +396,9 @@ class Tilemap:
         with open(target_path, "w") as f:
             JSONDump(save_data, f, indent=2)
 
+        if hasattr(self.editor, "node_manager"):
+            self.editor.node_manager.save(target_path)
+
         print(f"Saved to {target_path}")
 
     def _project_base_path(self) -> Path:
@@ -544,6 +549,7 @@ class Tilemap:
                         tileset_type,
                         properties=ts_entry.get("properties", {}),
                         tile_properties=ts_entry.get("tile_properties", {}),
+                        animation=ts_entry.get("animation"),
                     )
                 except Exception as e:
                     error_msg = f"Error loading tileset {path_str}: {e}"
@@ -654,6 +660,11 @@ class Tilemap:
                     if active_layer:
                         active_layer.tiles[pos] = tile_data
 
+        if hasattr(self.editor, "node_manager"):
+            self.editor.node_manager.load(path)
+            if hasattr(self.editor, "node_selector"):
+                self.editor.node_selector._rebuild_filter()
+
         self.initialized = True
 
     def _object_tileset_indices_from_payload(self, payload: dict) -> set[int]:

{tilemap_editor-3.2.7 → tilemap_editor-3.2.9}/src/tilemap_editor/settings.py

@@ -23,6 +23,7 @@ def init_settings(generate_main: bool = False) -> None:
             "tileset": "collision",
             "character": "character_collision"
         },
+        "nodes_path": "nodes",
         "error_handler": {
             "log_path": "errors.log",
             "max_recent_errors": 50,

{tilemap_editor-3.2.7 → tilemap_editor-3.2.9/src/tilemap_editor.egg-info}/PKG-INFO

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

{tilemap_editor-3.2.7 → tilemap_editor-3.2.9}/src/tilemap_editor.egg-info/SOURCES.txt

@@ -45,6 +45,8 @@ src/editor.py
 src/event_map.py
 src/layers.py
 src/main.py
+src/node_manager.py
+src/nodes.py
 src/standalone_automap.py
 src/standalone_error_console.py
 src/standalone_filemanager.py
@@ -170,6 +172,8 @@ src/widgets/ui/fileinput.py
 src/widgets/ui/layer_type_dialog.py
 src/widgets/ui/menubar.py
 src/widgets/ui/mode_indicator.py
+src/widgets/ui/node_editor.py
+src/widgets/ui/node_selector.py
 src/widgets/ui/notification.py
 src/widgets/ui/property_editor.py
 src/widgets/ui/region_selector.py

{tilemap_editor-3.2.7 → tilemap_editor-3.2.9}/src/ttypes/tilemap.py

@@ -64,6 +64,7 @@ class TypeTilesetSerialized(TypedDict, total=True):
     type: str
     properties: NotRequired[Dict[str, Any]]
     tile_properties: NotRequired[Dict[str, Dict[str, Any]]]  # variant_id string -> properties
+    animation: NotRequired[dict]
 
 
 TTile = Dict[Tuple[int, int], TypeTile]

{tilemap_editor-3.2.7 → tilemap_editor-3.2.9}/src/widgets/layer_selector.py

@@ -44,6 +44,8 @@ class LayerSelector:
         self.rename_text: str = ""
         self.rename_original_name: str = ""
 
+        self._adjusting_opacity_idx: Optional[int] = None
+
         btn_h = 25
         btn_w = 25
         btn_y = self.footer_rect.y + 5
@@ -113,6 +115,19 @@ class LayerSelector:
                                 layer.locked = not layer.locked
                                 return True
 
+                        opacity_rect = self._get_opacity_bar_rect(layer_idx)
+                        if opacity_rect and opacity_rect.collidepoint(mouse_pos):
+                            layer = self.editor.tilemap.layer_manager.get_layer(
+                                layer_idx
+                            )
+                            if layer:
+                                self._adjusting_opacity_idx = layer_idx
+                                rel_x = mouse_pos[0] - opacity_rect.x
+                                layer.opacity = max(
+                                    0.0, min(1.0, rel_x / opacity_rect.width)
+                                )
+                                return True
+
                         self.dragging_layer_idx = layer_idx
                         self.drag_start_y = mouse_pos[1]
 
@@ -153,6 +168,9 @@ class LayerSelector:
                     return True
 
         elif event.type == pygame.MOUSEBUTTONUP:
+            if event.button == 1:
+                self._adjusting_opacity_idx = None
+
             if event.button == 1 and self.dragging_layer_idx is not None:
                 layer_idx = self._get_layer_at_pos(mouse_pos)
                 if layer_idx is not None and layer_idx != self.dragging_layer_idx:
@@ -164,6 +182,19 @@ class LayerSelector:
                 return True
 
         elif event.type == pygame.MOUSEMOTION:
+            if self._adjusting_opacity_idx is not None:
+                layer = self.editor.tilemap.layer_manager.get_layer(
+                    self._adjusting_opacity_idx
+                )
+                if layer:
+                    opacity_rect = self._get_opacity_bar_rect(
+                        self._adjusting_opacity_idx
+                    )
+                    if opacity_rect:
+                        rel_x = max(0, min(opacity_rect.width, mouse_pos[0] - opacity_rect.x))
+                        layer.opacity = max(0.0, min(1.0, rel_x / opacity_rect.width))
+                return True
+
             if self.list_rect.collidepoint(mouse_pos):
                 if self.dragging_layer_idx is None:
                     self.hover_idx = self._get_layer_at_pos(mouse_pos)
@@ -188,7 +219,13 @@ class LayerSelector:
                     self._cancel_rename()
                     return True
                 elif event.key == pygame.K_BACKSPACE:
-                    self.rename_text = self.rename_text[:-1]
+                    pressed = pygame.key.get_pressed()
+                    meta_down = pressed[pygame.K_LMETA] or pressed[pygame.K_RMETA]
+                    ctrl_down = pressed[pygame.K_LCTRL] or pressed[pygame.K_RCTRL]
+                    if meta_down or ctrl_down:
+                        self.rename_text = ""
+                    else:
+                        self.rename_text = self.rename_text[:-1]
                     return True
                 else:
                     if event.unicode.isprintable():
@@ -219,6 +256,19 @@ class LayerSelector:
 
         return None
 
+    def _get_opacity_bar_rect(self, layer_idx: int) -> Optional[Rect]:
+        """Get the clickable rect for the opacity bar of a layer."""
+        item_y = self.list_rect.y + (layer_idx * self.item_h) - self.scroll_offset
+
+        if item_y + self.item_h < self.list_rect.y or item_y > self.list_rect.bottom:
+            return None
+
+        bar_w = 46
+        bar_h = 6
+        bar_x = self.list_rect.x + self.list_rect.width - 80
+        bar_y = item_y + self.item_h - bar_h - 3
+        return Rect(bar_x, bar_y, bar_w, bar_h)
+
     def _get_eye_icon_rect(self, layer_idx: int, mouse_pos) -> Optional[Rect]:
         """Get the clickable rect for the eye icon of a layer."""
         if layer_idx is None:
@@ -404,6 +454,18 @@ class LayerSelector:
                 name_txt = self.font_layer.render(layer.name, True, self.text_color)
             screen.blit(name_txt, (item_rect.x + 5, item_rect.y + 5))
 
+            opacity_bar = self._get_opacity_bar_rect(i)
+            if opacity_bar:
+                bg_rect = Rect(opacity_bar.x, opacity_bar.y, opacity_bar.width, opacity_bar.height)
+                pygame.draw.rect(screen, (60, 60, 60), bg_rect, border_radius=2)
+                fill_w = int(opacity_bar.width * layer.opacity)
+                if fill_w > 0:
+                    fill_rect = Rect(opacity_bar.x, opacity_bar.y, fill_w, opacity_bar.height)
+                    green = int(180 * layer.opacity) + 40
+                    pygame.draw.rect(screen, (40, green, 40), fill_rect, border_radius=2)
+                pct_txt = self.font_layer.render(f"{int(layer.opacity * 100)}%", True, self.text_muted)
+                screen.blit(pct_txt, (opacity_bar.x - 32, opacity_bar.y - 2))
+
             eye_x = item_rect.right - 25
             eye_y = item_rect.y + 7
             if layer.visible: