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

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

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

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

@@ -40,6 +40,7 @@ from .map_parse import (
     ParsedProjectState,
     ParsedTile,
     ParsedTileset,
+    TilesetAnimation,
     parse_map_dict,
     parse_map_file,
     parse_map_json,
@@ -72,6 +73,7 @@ __all__ = [
     "ParsedTile",
     "ParsedTileset",
     "RectangleShape",
+    "TilesetAnimation",
     "TileCollisionData",
     "TilesetCollision",
     "parse_animation_dict",

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

@@ -125,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
@@ -340,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.8 → tilemap_parser-3.1.9}/src/tilemap_parser/runtime/map_loader.py

@@ -198,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.8 → 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.8 → 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.8
+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