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

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

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

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

@@ -1,13 +1,15 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Dict, Optional, Tuple, Union
+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:
@@ -28,7 +30,9 @@ class TileLayerRenderer:
             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:
@@ -52,15 +56,26 @@ class TileLayerRenderer:
                     "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
-            )
+            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
@@ -70,7 +85,15 @@ class TileLayerRenderer:
         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):
+                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
 
@@ -85,13 +108,15 @@ class TileLayerRenderer:
         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
+        frame_idx = (time_ms // anim["frame_duration_ms"]) % frame_count
+
         if anim.get("animation_mode") == "random_start_times":
-            phase = hash((x, y, ttype)) % frame_count
+            phase = ((x * 73856093) ^ (y * 19349663) ^ (ttype * 83492791)) % frame_count
             frame_idx = (frame_idx + phase) % frame_count
-        return variant + frame_idx * stride
+
+        return variant + frame_idx * anim["frame_stride"]
 
     def render(
         self,
@@ -101,6 +126,13 @@ class TileLayerRenderer:
         *,
         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()
@@ -120,27 +152,40 @@ class TileLayerRenderer:
         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
-            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
-                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
+
+            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.9 → 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.9
+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