tilemap-parser 3.1.0__tar.gz → 3.1.2__tar.gz

{tilemap_parser-3.1.0 → tilemap_parser-3.1.2}/PKG-INFO

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

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

@@ -29,9 +29,9 @@ class CollisionPolygon:
     vertices: List[Point]
     one_way: bool = False
 
-    def transform(self, tile_x: float, tile_y: float) -> "CollisionPolygon":
+    def transform(self, tile_x: float, tile_y: float, scale: float = 1.0) -> "CollisionPolygon":
         """Transform polygon to world space coordinates"""
-        world_vertices = [(tile_x + vx, tile_y + vy) for vx, vy in self.vertices]
+        world_vertices = [(tile_x + vx * scale, tile_y + vy * scale) for vx, vy in self.vertices]
         return CollisionPolygon(vertices=world_vertices, one_way=self.one_way)
 
     def is_valid(self) -> bool:
@@ -69,13 +69,13 @@ class TilesetCollision:
         return tile_data is not None and tile_data.has_collision()
 
     def get_world_shapes(
-        self, tile_id: int, tile_x: float, tile_y: float
+        self, tile_id: int, tile_x: float, tile_y: float, scale: float = 1.0
     ) -> List[CollisionPolygon]:
         """Get collision shapes transformed to world space"""
         tile_data = self.get_tile_collision(tile_id)
         if not tile_data:
             return []
-        return [shape.transform(tile_x, tile_y) for shape in tile_data.shapes]
+        return [shape.transform(tile_x, tile_y, scale) for shape in tile_data.shapes]
 
 
 @dataclass

{tilemap_parser-3.1.0 → tilemap_parser-3.1.2}/src/tilemap_parser/parser/map_parse.py

@@ -170,6 +170,7 @@ class ParsedMeta:
     zoom_level: float
     scroll: Point
     version: str
+    render_scale: float = 1.0
 
 
 @dataclass
@@ -394,6 +395,7 @@ def parse_map_dict(root: JsonDict) -> ParsedMap:
         zoom_level=_coerce_float(meta_obj.get("zoom_level", 1.0), "meta.zoom_level"),
         scroll=_parse_point_field(meta_obj.get("scroll"), "meta.scroll", default="0;0"),
         version=_require_str(meta_obj.get("version", "1.1"), "meta.version"),
+        render_scale=_coerce_float(meta_obj.get("render_scale", 1.0), "meta.render_scale"),
     )
 
     data_obj = _require_dict(root.get("data"), "data")

{tilemap_parser-3.1.0 → tilemap_parser-3.1.2}/src/tilemap_parser/runtime/map_loader.py

@@ -114,6 +114,10 @@ class TilemapData:
     def map_size(self) -> Tuple[int, int]:
         return self.parsed.meta.map_size
 
+    @property
+    def render_scale(self) -> float:
+        return self.parsed.meta.render_scale
+
     def get_raw(self) -> dict:
         return deepcopy(self.parsed.raw)
 

{tilemap_parser-3.1.0 → tilemap_parser-3.1.2}/src/tilemap_parser/runtime/renderer.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Dict, Optional, Tuple, Union
 
-from pygame import Rect, Surface
+from pygame import Rect, Surface, transform
 
 from .map_loader import TilemapData
 
@@ -29,6 +29,11 @@ class TileLayerRenderer:
         )
         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)
 
     def get_layer_dict(self) -> Dict[int, object]:
         return dict(self.tile_layers)
@@ -36,9 +41,12 @@ class TileLayerRenderer:
     def _get_cached_variant(self, ttype: int, variant: int) -> Optional[Surface]:
         key = (ttype, variant)
         if key not in self._variant_cache:
-            self._variant_cache[key] = self.data.get_tile_surface(
+            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:
@@ -61,10 +69,10 @@ class TileLayerRenderer:
         else:
             viewport = Rect(0, 0, viewport_size[0], viewport_size[1])
 
-        min_x = int(cam_x // self._tile_w) - 1
-        max_x = int((cam_x + viewport.width) // self._tile_w) + 1
-        min_y = int(cam_y // self._tile_h) - 1
-        max_y = int((cam_y + viewport.height) // self._tile_h) + 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
@@ -86,7 +94,7 @@ class TileLayerRenderer:
                 if cell is None:
                     skipped += 1
                     continue
-                target.blit(cell, (x * self._tile_w - cam_x, y * self._tile_h - cam_y))
+                target.blit(cell, (x * self._eff_w - cam_x, y * self._eff_h - cam_y))
                 drawn += 1
 
         return LayerRenderStats(