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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 3.1.7
+Version: 3.1.9
 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.9}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "3.1.7"
+version = "3.1.9"
 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.9}/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.9}/src/tilemap_parser/parser/__init__.py

@@ -40,10 +40,12 @@ from .map_parse import (
     ParsedProjectState,
     ParsedTile,
     ParsedTileset,
+    TilesetAnimation,
     parse_map_dict,
     parse_map_file,
     parse_map_json,
 )
+from .node_parse import ParsedNode, parse_nodes_dict, parse_nodes_file
 
 __all__ = [
     "AnimationClip",
@@ -60,6 +62,7 @@ __all__ = [
     "ObjectCollisionData",
     "ObjectCollisionRegionData",
     "ParsedAutotileGroup",
+    "ParsedNode",
     "ParsedAutotileRule",
     "ParsedLayer",
     "ParsedMap",
@@ -70,6 +73,7 @@ __all__ = [
     "ParsedTile",
     "ParsedTileset",
     "RectangleShape",
+    "TilesetAnimation",
     "TileCollisionData",
     "TilesetCollision",
     "parse_animation_dict",
@@ -82,6 +86,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.9}/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]
@@ -122,12 +125,22 @@ class ParsedObject:
     properties: Optional[JsonDict] = None
 
 
+@dataclass
+class TilesetAnimation:
+    frame_count: int
+    frame_duration_ms: float
+    frame_stride: int
+    loop: bool = True
+    animation_mode: str = "default"
+
+
 @dataclass
 class ParsedTileset:
     path: str
     type: str
     properties: JsonDict = field(default_factory=dict)
     tile_properties: Dict[str, JsonDict] = field(default_factory=dict)
+    animation: Optional[TilesetAnimation] = None
 
 
 @dataclass
@@ -187,6 +200,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:
@@ -335,9 +350,21 @@ def _parse_tilesets_list(tilesets_raw: List[Any], ctx: str) -> List[ParsedTilese
                 tile_props[str(k)] = _require_dict(
                     v, f"{ctx}[{i}].tile_properties[{k!r}]"
                 )
+        animation = None
+        animation_raw = ts_obj.get("animation")
+        if animation_raw is not None:
+            anim_obj = _require_dict(animation_raw, f"{ctx}[{i}].animation")
+            animation = TilesetAnimation(
+                frame_count=_coerce_int(anim_obj.get("frame_count"), f"{ctx}[{i}].animation.frame_count"),
+                frame_duration_ms=_coerce_float(anim_obj.get("frame_duration_ms"), f"{ctx}[{i}].animation.frame_duration_ms"),
+                frame_stride=_coerce_int(anim_obj.get("frame_stride"), f"{ctx}[{i}].animation.frame_stride"),
+                loop=_coerce_bool(anim_obj.get("loop", True), f"{ctx}[{i}].animation.loop"),
+                animation_mode=_require_str(anim_obj.get("animation_mode", "default"), f"{ctx}[{i}].animation.animation_mode"),
+            )
         out.append(
             ParsedTileset(
-                path=path, type=ts_type, properties=props, tile_properties=tile_props
+                path=path, type=ts_type, properties=props, tile_properties=tile_props,
+                animation=animation,
             )
         )
     return out

tilemap_parser-3.1.9/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.9}/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.9/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.9}/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:
@@ -175,6 +198,19 @@ class TilemapData:
             return None
         return self.get_tile_surface(tile.ttype, tile.variant)
 
+    def get_tileset_animation(self, ttype: int) -> Optional[dict]:
+        if 0 <= ttype < len(self.parsed.tilesets):
+            anim = self.parsed.tilesets[ttype].animation
+            if anim is not None:
+                return {
+                    "frame_count": anim.frame_count,
+                    "frame_duration_ms": anim.frame_duration_ms,
+                    "frame_stride": anim.frame_stride,
+                    "loop": anim.loop,
+                    "animation_mode": anim.animation_mode,
+                }
+        return None
+
 
 def _variant_surface(
     surf: Surface,

{tilemap_parser-3.1.7 → tilemap_parser-3.1.9}/src/tilemap_parser/runtime/renderer.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Dict, Optional, Tuple, Union
 
+import pygame
 from pygame import Rect, Surface, transform
 
 from .map_loader import TilemapData
@@ -40,6 +41,17 @@ class TileLayerRenderer:
                 f"got tile_size=({self._tile_w}, {self._tile_h}) render_scale={self._rs}"
             )
 
+        self._tileset_animations: Dict[int, dict] = {}
+        for ts_idx, ts in enumerate(data.parsed.tilesets):
+            if ts.animation is not None:
+                self._tileset_animations[ts_idx] = {
+                    "frame_count": ts.animation.frame_count,
+                    "frame_duration_ms": ts.animation.frame_duration_ms,
+                    "frame_stride": ts.animation.frame_stride,
+                    "loop": ts.animation.loop,
+                    "animation_mode": ts.animation.animation_mode,
+                }
+
     def get_layer_dict(self) -> Dict[int, object]:
         return dict(self.tile_layers)
 
@@ -62,11 +74,32 @@ class TileLayerRenderer:
                     self._get_cached_variant(tile.ttype, tile.variant)
         self.data = None
 
+    def _compute_display_variant(
+        self,
+        variant: int,
+        ttype: int,
+        x: int,
+        y: int,
+        time_ms: int,
+    ) -> int:
+        anim = self._tileset_animations.get(ttype)
+        if anim is None:
+            return variant
+        stride = anim["frame_stride"]
+        frame_count = anim["frame_count"]
+        frame_idx = int(time_ms / anim["frame_duration_ms"]) % frame_count
+        if anim.get("animation_mode") == "random_start_times":
+            phase = hash((x, y, ttype)) % frame_count
+            frame_idx = (frame_idx + phase) % frame_count
+        return variant + frame_idx * stride
+
     def render(
         self,
         target: Surface,
         camera_xy: Union[Tuple[float, float], Tuple[int, int]] = (0, 0),
         viewport_size: Optional[Tuple[int, int]] = None,
+        *,
+        current_time_ms: Optional[float] = None,
     ) -> LayerRenderStats:
         cam_x, cam_y = float(camera_xy[0]), float(camera_xy[1])
         if viewport_size is None:
@@ -79,6 +112,10 @@ class TileLayerRenderer:
         min_y = int(cam_y // self._eff_h) - 1
         max_y = int((cam_y + viewport.height) // self._eff_h) + 1
 
+        if current_time_ms is None:
+            current_time_ms = pygame.time.get_ticks()
+        time_ms = int(current_time_ms)
+
         drawn = 0
         skipped = 0
         visible_layers = 0
@@ -95,7 +132,10 @@ class TileLayerRenderer:
                 if not isinstance(tile.ttype, int):
                     skipped += 1
                     continue
-                cell = self._get_cached_variant(tile.ttype, tile.variant)
+                display_variant = self._compute_display_variant(
+                    tile.variant, tile.ttype, x, y, time_ms
+                )
+                cell = self._get_cached_variant(tile.ttype, display_variant)
                 if cell is None:
                     skipped += 1
                     continue

{tilemap_parser-3.1.7 → tilemap_parser-3.1.9}/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.9
 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.9}/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