tilemap-parser 3.1.7__tar.gz → 3.1.8__tar.gz

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 3.1.7
+Version: 3.1.8
 Summary: Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime.
 Author: tilemap parser contributors
 License:                     GNU GENERAL PUBLIC LICENSE

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "3.1.7"
+version = "3.1.8"
 description = "Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime."
 readme = "README.md"
 requires-python = ">=3.10"

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/src/tilemap_parser/__init__.py

@@ -9,6 +9,7 @@ __all__ = [
     "AnimationMarker",
     "AnimationParseError",
     "AnimationPlayer",
+    "AreaNode",
     "CapsuleShape",
     "CharacterCollision",
     "CircleShape",
@@ -32,6 +33,7 @@ __all__ = [
     "ParsedLayer",
     "ParsedMap",
     "ParsedMeta",
+    "ParsedNode",
     "ParsedObject",
     "ParsedObjectArea",
     "ParsedProjectState",
@@ -62,6 +64,8 @@ __all__ = [
     "parse_map_dict",
     "parse_map_file",
     "parse_map_json",
+    "parse_nodes_dict",
+    "parse_nodes_file",
     "parse_object_collision",
     "parse_tileset_collision",
     "polygon_vs_circle",

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/src/tilemap_parser/parser/__init__.py

@@ -44,6 +44,7 @@ from .map_parse import (
     parse_map_file,
     parse_map_json,
 )
+from .node_parse import ParsedNode, parse_nodes_dict, parse_nodes_file
 
 __all__ = [
     "AnimationClip",
@@ -60,6 +61,7 @@ __all__ = [
     "ObjectCollisionData",
     "ObjectCollisionRegionData",
     "ParsedAutotileGroup",
+    "ParsedNode",
     "ParsedAutotileRule",
     "ParsedLayer",
     "ParsedMap",
@@ -82,6 +84,8 @@ __all__ = [
     "parse_map_dict",
     "parse_map_file",
     "parse_map_json",
+    "parse_nodes_dict",
+    "parse_nodes_file",
     "parse_object_collision",
     "parse_tileset_collision",
 ]

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/src/tilemap_parser/parser/map_parse.py

@@ -5,7 +5,10 @@ import re
 import string
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
+
+if TYPE_CHECKING:
+    from .node_parse import ParsedNode
 
 JsonDict = Dict[str, Any]
 Point = Tuple[int, int]
@@ -187,6 +190,8 @@ class ParsedMap:
     tilesets: List[ParsedTileset]
     project_state: ParsedProjectState
     raw: JsonDict
+    nodes: List["ParsedNode"] = field(default_factory=list)
+    node_groups: List[str] = field(default_factory=list)
 
 
 def _parse_tile(tile_data: JsonDict, ctx: str) -> ParsedTile:

tilemap_parser-3.1.8/src/tilemap_parser/parser/node_parse.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Union
+
+from .map_parse import (
+    JsonDict,
+    MapParseError,
+    ParsedObjectArea,
+    _coerce_bool,
+    _coerce_float,
+    _coerce_int,
+    _optional_dict,
+    _require_dict,
+    _require_list,
+    _require_str,
+    _ctx,
+)
+
+
+@dataclass
+class ParsedNode:
+    node_id: str
+    name: str
+    node_type: str
+    area: ParsedObjectArea
+    layer_name: str
+    properties: JsonDict = field(default_factory=dict)
+    group: Optional[str] = None
+
+
+def _parse_area(raw: Any, ctx: str) -> ParsedObjectArea:
+    d = _require_dict(raw, ctx)
+    return ParsedObjectArea(
+        x=_coerce_int(d.get("x"), f"{ctx}.x"),
+        y=_coerce_int(d.get("y"), f"{ctx}.y"),
+        w=_coerce_int(d.get("w"), f"{ctx}.w"),
+        h=_coerce_int(d.get("h"), f"{ctx}.h"),
+    )
+
+
+def _parse_node(raw: Any, ctx: str) -> ParsedNode:
+    d = _require_dict(raw, ctx)
+    group_raw = d.get("group")
+    group = str(group_raw) if group_raw is not None else None
+    return ParsedNode(
+        node_id=_require_str(d.get("node_id"), f"{ctx}.node_id"),
+        name=_require_str(d.get("name"), f"{ctx}.name"),
+        node_type=_require_str(d.get("node_type", "area"), f"{ctx}.node_type"),
+        area=_parse_area(d.get("area"), f"{ctx}.area"),
+        layer_name=_require_str(d.get("layer_name", ""), f"{ctx}.layer_name"),
+        properties=_optional_dict(d.get("properties"), f"{ctx}.properties") or {},
+        group=group,
+    )
+
+
+def parse_nodes_dict(root: JsonDict) -> List[ParsedNode]:
+    root = _require_dict(root, "root")
+    raw_nodes = _require_list(root.get("nodes", []), "root.nodes")
+    return [_parse_node(item, f"root.nodes[{i}]") for i, item in enumerate(raw_nodes)]
+
+
+def parse_nodes_file(path: Union[str, Path]) -> List[ParsedNode]:
+    p = Path(path)
+    if not p.is_file():
+        raise MapParseError(f"Not a file: {p}")
+    try:
+        text = p.read_text(encoding="utf-8")
+    except OSError as e:
+        raise MapParseError(f"Cannot read {p}: {e}") from e
+    try:
+        payload = json.loads(text)
+    except json.JSONDecodeError as e:
+        raise MapParseError(f"Invalid JSON in {p}: {e}") from e
+    return parse_nodes_dict(payload)

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/src/tilemap_parser/runtime/__init__.py

@@ -23,9 +23,11 @@ from .object_collision import (
     check_collision,
 )
 from .renderer import LayerRenderStats, TileLayerRenderer
+from .area_node import AreaNode
 
 __all__ = [
     "AnimationPlayer",
+    "AreaNode",
     "CollisionCache",
     "CollisionHit",
     "CollisionResult",

tilemap_parser-3.1.8/src/tilemap_parser/runtime/area_node.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Optional, Tuple
+
+from pygame import Rect
+
+from ..parser.node_parse import ParsedNode
+
+
+class AreaNode:
+    def __init__(self, parsed: ParsedNode) -> None:
+        self.node_id = parsed.node_id
+        self.name = parsed.name
+        self.node_type = parsed.node_type
+        self._rect = Rect(parsed.area.x, parsed.area.y, parsed.area.w, parsed.area.h)
+        self.layer_name = parsed.layer_name
+        self.properties = dict(parsed.properties)
+        self.group = parsed.group
+
+    @property
+    def rect(self) -> Rect:
+        return self._rect
+
+    @rect.setter
+    def rect(self, r: Rect) -> None:
+        self._rect = r
+
+    def contains_point(self, point: Tuple[float, float]) -> bool:
+        return self._rect.collidepoint(point)
+
+    def overlaps_rect(self, other: Rect) -> bool:
+        return self._rect.colliderect(other)
+
+    def __repr__(self) -> str:
+        return (
+            f"AreaNode(id={self.node_id!r}, name={self.name!r}, "
+            f"rect={self._rect}, layer={self.layer_name!r})"
+        )

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/src/tilemap_parser/runtime/map_loader.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from copy import deepcopy
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple, Union
@@ -8,6 +9,7 @@ import pygame
 from pygame import Rect, Surface
 
 from ..parser.map_parse import MapParseError, ParsedLayer, ParsedMap, ParsedTile, parse_map_file
+from ..parser.node_parse import parse_nodes_dict
 
 PathLike = Union[str, Path]
 
@@ -66,6 +68,27 @@ class TilemapData:
                     raise MapParseError(msg) from e
                 surfaces.append(None)
 
+        nodes_name = f"{p.stem}.nodes.json"
+        nodes_candidates = [
+            map_dir / nodes_name,
+            map_dir.parent / "nodes" / nodes_name,
+        ]
+        if extra_search_base is not None:
+            nodes_candidates.append(extra_search_base / "nodes" / nodes_name)
+        for nodes_path in nodes_candidates:
+            if nodes_path.is_file():
+                try:
+                    nodes_text = nodes_path.read_text(encoding="utf-8")
+                    nodes_raw = json.loads(nodes_text)
+                    parsed.nodes = parse_nodes_dict(nodes_raw)
+                    groups_raw = nodes_raw.get("groups", [])
+                    if not isinstance(groups_raw, list):
+                        raise MapParseError("root.groups must be a list")
+                    parsed.node_groups = groups_raw
+                except (json.JSONDecodeError, OSError, MapParseError) as e:
+                    warnings.append(f"Failed to load nodes: {e}")
+                break
+
         return cls(parsed, surfaces, resolved_paths, warnings, map_path=p)
 
     def _build_path_index(self) -> None:

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/src/tilemap_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 3.1.7
+Version: 3.1.8
 Summary: Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime.
 Author: tilemap parser contributors
 License:                     GNU GENERAL PUBLIC LICENSE

{tilemap_parser-3.1.7 → tilemap_parser-3.1.8}/src/tilemap_parser.egg-info/SOURCES.txt

@@ -12,8 +12,10 @@ src/tilemap_parser/parser/animation.py
 src/tilemap_parser/parser/collision.py
 src/tilemap_parser/parser/collision_loader.py
 src/tilemap_parser/parser/map_parse.py
+src/tilemap_parser/parser/node_parse.py
 src/tilemap_parser/runtime/__init__.py
 src/tilemap_parser/runtime/animation_player.py
+src/tilemap_parser/runtime/area_node.py
 src/tilemap_parser/runtime/collision_cache.py
 src/tilemap_parser/runtime/map_loader.py
 src/tilemap_parser/runtime/object_collision.py