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

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

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

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

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple, Union
+
+import pygame
+from pygame import Rect, Surface, transform
+
+from .map_loader import TilemapData
+
+CHUNK_SIZE = 32
+
+
+@dataclass(frozen=True)
+class LayerRenderStats:
+    drawn_tiles: int
+    skipped_tiles: int
+    visible_layers: int
+
+
+class TileLayerRenderer:
+    def __init__(
+        self, data: TilemapData, *, include_hidden_layers: bool = False
+    ) -> None:
+        self.data = data
+        self.tile_layers = data.get_tile_layers_dict(
+            include_hidden=include_hidden_layers
+        )
+        self._sorted_layer_ids = sorted(
+            self.tile_layers.keys(),
+            key=lambda lid: (self.tile_layers[lid].z_index, lid),
+        )
+
+        self._variant_cache: Dict[Tuple[int, int], Optional[Surface]] = {}
+
+        self._tile_w, self._tile_h = data.tile_size
+        self._rs = data.render_scale
+        if self._rs <= 0:
+            raise ValueError(f"render_scale must be positive, got {self._rs}")
+        self._eff_w = int(self._tile_w * self._rs)
+        self._eff_h = int(self._tile_h * self._rs)
+        if self._eff_w <= 0 or self._eff_h <= 0:
+            raise ValueError(
+                f"effective tile size ({self._eff_w}, {self._eff_h}) must be positive; "
+                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,
+                }
+
+        self._layer_chunks: Dict[int, Dict[Tuple[int, int], List[Tuple[int, int]]]] = {}
+        for layer_id, layer in self.tile_layers.items():
+            chunks: Dict[Tuple[int, int], List[Tuple[int, int]]] = {}
+            for (x, y), tile in layer.tiles.items():
+                if not isinstance(tile.ttype, int):
+                    continue
+                cx, cy = x // CHUNK_SIZE, y // CHUNK_SIZE
+                chunk_key = (cx, cy)
+                if chunk_key not in chunks:
+                    chunks[chunk_key] = []
+                chunks[chunk_key].append((x, y))
+            self._layer_chunks[layer_id] = chunks
+
+    def get_layer_dict(self) -> Dict[int, object]:
+        return dict(self.tile_layers)
+
+    def _get_cached_variant(self, ttype: int, variant: int) -> Optional[Surface]:
+        key = (ttype, variant)
+        if key not in self._variant_cache:
+            cell = self.data.get_tile_surface(ttype, variant, copy_surface=True)
+            if cell is not None and self._rs != 1.0:
+                cell = transform.scale(cell, (self._eff_w, self._eff_h))
+            self._variant_cache[key] = cell
+        return self._variant_cache[key]
+
+    def warm_cache(self) -> None:
+        for layer_id in self._sorted_layer_ids:
+            layer = self.tile_layers[layer_id]
+            for tile in layer.tiles.values():
+                if not isinstance(tile.ttype, int):
+                    continue
+                anim = self._tileset_animations.get(tile.ttype)
+                if anim is not None:
+                    frame_count = anim["frame_count"]
+                    stride = anim["frame_stride"]
+                    for f in range(frame_count):
+                        self._get_cached_variant(tile.ttype, tile.variant + f * stride)
+                else:
+                    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
+
+        frame_count = anim["frame_count"]
+        frame_idx = (time_ms // anim["frame_duration_ms"]) % frame_count
+
+        if anim.get("animation_mode") == "random_start_times":
+            phase = ((x * 73856093) ^ (y * 19349663) ^ (ttype * 83492791)) % frame_count
+            frame_idx = (frame_idx + phase) % frame_count
+
+        return variant + frame_idx * anim["frame_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:
+        """Render visible tile layers.
+
+        Note: ``skipped_tiles`` is a debugging indicator, not a whole-map
+        accumulated count. It tracks null surfaces and invalid tiles within
+        the active chunk range — enough to spot rendering issues without
+        the cost of a full scan.
+        """
+        cam_x, cam_y = float(camera_xy[0]), float(camera_xy[1])
+        if viewport_size is None:
+            viewport = target.get_rect()
+        else:
+            viewport = Rect(0, 0, viewport_size[0], viewport_size[1])
+
+        min_x = int(cam_x // self._eff_w) - 1
+        max_x = int((cam_x + viewport.width) // self._eff_w) + 1
+        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
+
+        min_cx = min_x // CHUNK_SIZE
+        max_cx = max_x // CHUNK_SIZE
+        min_cy = min_y // CHUNK_SIZE
+        max_cy = max_y // CHUNK_SIZE
+
+        for layer_id in self._sorted_layer_ids:
+            layer = self.tile_layers[layer_id]
+            if not layer.visible:
+                continue
+            visible_layers += 1
+
+            chunks = self._layer_chunks[layer_id]
+
+            for cx in range(min_cx, max_cx + 1):
+                for cy in range(min_cy, max_cy + 1):
+                    chunk = chunks.get((cx, cy))
+                    if not chunk:
+                        continue
+
+                    for x, y in chunk:
+                        tile = layer.tiles[(x, y)]
+                        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
+
+                        target.blit(
+                            cell,
+                            (x * self._eff_w - cam_x, y * self._eff_h - cam_y),
+                        )
+                        drawn += 1
+
+        return LayerRenderStats(
+            drawn_tiles=drawn, skipped_tiles=skipped, visible_layers=visible_layers
+        )

{tilemap_parser-3.1.8 → tilemap_parser-3.1.10}/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.10
 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/src/tilemap_parser/runtime/renderer.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict, Optional, Tuple, Union
-
-from pygame import Rect, Surface, transform
-
-from .map_loader import TilemapData
-
-
-@dataclass(frozen=True)
-class LayerRenderStats:
-    drawn_tiles: int
-    skipped_tiles: int
-    visible_layers: int
-
-
-class TileLayerRenderer:
-    def __init__(
-        self, data: TilemapData, *, include_hidden_layers: bool = False
-    ) -> None:
-        self.data = data
-        self.tile_layers = data.get_tile_layers_dict(
-            include_hidden=include_hidden_layers
-        )
-        self._sorted_layer_ids = sorted(
-            self.tile_layers.keys(),
-            key=lambda lid: (self.tile_layers[lid].z_index, lid),
-        )
-        self._variant_cache: Dict[Tuple[int, int], Optional[Surface]] = {}
-        self._tile_w, self._tile_h = data.tile_size
-        self._rs = data.render_scale
-        if self._rs <= 0:
-            raise ValueError(f"render_scale must be positive, got {self._rs}")
-        self._eff_w = int(self._tile_w * self._rs)
-        self._eff_h = int(self._tile_h * self._rs)
-        if self._eff_w <= 0 or self._eff_h <= 0:
-            raise ValueError(
-                f"effective tile size ({self._eff_w}, {self._eff_h}) must be positive; "
-                f"got tile_size=({self._tile_w}, {self._tile_h}) render_scale={self._rs}"
-            )
-
-    def get_layer_dict(self) -> Dict[int, object]:
-        return dict(self.tile_layers)
-
-    def _get_cached_variant(self, ttype: int, variant: int) -> Optional[Surface]:
-        key = (ttype, variant)
-        if key not in self._variant_cache:
-            cell = self.data.get_tile_surface(
-                ttype, variant, copy_surface=True
-            )
-            if cell is not None and self._rs != 1.0:
-                cell = transform.scale(cell, (self._eff_w, self._eff_h))
-            self._variant_cache[key] = cell
-        return self._variant_cache[key]
-
-    def warm_cache(self) -> None:
-        for layer_id in self._sorted_layer_ids:
-            layer = self.tile_layers[layer_id]
-            for tile in layer.tiles.values():
-                if isinstance(tile.ttype, int):
-                    self._get_cached_variant(tile.ttype, tile.variant)
-        self.data = None
-
-    def render(
-        self,
-        target: Surface,
-        camera_xy: Union[Tuple[float, float], Tuple[int, int]] = (0, 0),
-        viewport_size: Optional[Tuple[int, int]] = None,
-    ) -> LayerRenderStats:
-        cam_x, cam_y = float(camera_xy[0]), float(camera_xy[1])
-        if viewport_size is None:
-            viewport = target.get_rect()
-        else:
-            viewport = Rect(0, 0, viewport_size[0], viewport_size[1])
-
-        min_x = int(cam_x // self._eff_w) - 1
-        max_x = int((cam_x + viewport.width) // self._eff_w) + 1
-        min_y = int(cam_y // self._eff_h) - 1
-        max_y = int((cam_y + viewport.height) // self._eff_h) + 1
-
-        drawn = 0
-        skipped = 0
-        visible_layers = 0
-
-        for layer_id in self._sorted_layer_ids:
-            layer = self.tile_layers[layer_id]
-            if not layer.visible:
-                continue
-            visible_layers += 1
-            for (x, y), tile in layer.tiles.items():
-                if x < min_x or x > max_x or y < min_y or y > max_y:
-                    skipped += 1
-                    continue
-                if not isinstance(tile.ttype, int):
-                    skipped += 1
-                    continue
-                cell = self._get_cached_variant(tile.ttype, tile.variant)
-                if cell is None:
-                    skipped += 1
-                    continue
-                target.blit(cell, (x * self._eff_w - cam_x, y * self._eff_h - cam_y))
-                drawn += 1
-
-        return LayerRenderStats(
-            drawn_tiles=drawn, skipped_tiles=skipped, visible_layers=visible_layers
-        )