tilemap-parser 4.2.4__tar.gz → 4.2.6__tar.gz

{tilemap_parser-4.2.4 → tilemap_parser-4.2.6}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "4.2.4"
+version = "4.2.6"
 description = "Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime."
 readme = "README.md"
 requires-python = ">=3.10"

{tilemap_parser-4.2.4 → tilemap_parser-4.2.6}/src/tilemap_parser/runtime/area_node.py

@@ -8,11 +8,18 @@ from ..parser.node_parse import ParsedNode
 
 
 class AreaNode:
-    def __init__(self, parsed: ParsedNode) -> None:
+    def __init__(self, parsed: ParsedNode, render_scale: float = 1.0) -> 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.render_scale = render_scale
+        rs = render_scale
+        self._rect = Rect(
+            int(parsed.area.x * rs),
+            int(parsed.area.y * rs),
+            int(parsed.area.w * rs),
+            int(parsed.area.h * rs),
+        )
         self.layer_name = parsed.layer_name
         self.properties = dict(parsed.properties)
         self.group = parsed.group

{tilemap_parser-4.2.4 → tilemap_parser-4.2.6}/src/tilemap_parser/runtime/map_loader.py

@@ -109,7 +109,11 @@ class TilemapData:
         origin_offset = _normalize_origin(parsed)
         result = cls(parsed, surfaces, resolved_paths, warnings, map_path=p)
         result.origin_offset = origin_offset
-        result.area_nodes = [AreaNode(n) for n in parsed.nodes if n.node_type == "area"]
+        result.area_nodes = [
+            AreaNode(n, render_scale=result.render_scale)
+            for n in parsed.nodes
+            if n.node_type == "area"
+        ]
         result.particle_emitters = [
             ParticleEmitterNode(n) for n in parsed.nodes if n.node_type == "particle_emitter"
         ]
@@ -275,8 +279,8 @@ class TilemapData:
         return self.get_tile_surface(tile.ttype, tile.variant)
 
     def get_object_surface_by_id(
-        self, layer_id_or_name: Union[int, str], object_id: int, *, copy_surface: bool = True
-    ) -> Optional[Tuple[Surface, int, int]]:
+        self, layer_id_or_name: Union[int, str], object_id: int, *, copy_surface: bool = True, scaled: bool = False
+    ) -> Optional[Tuple[Surface, float, float]]:
         layer = self.get_layer(layer_id_or_name)
         if layer is None or layer.layer_type != "object":
             return None
@@ -286,19 +290,31 @@ class TilemapData:
         surf = self.get_object_surface(obj, copy_surface=copy_surface)
         if surf is None:
             return None
-        return surf, obj.area.x, obj.area.y
+        rs = self.render_scale if scaled else 1.0
+        x = obj.area.x * rs
+        y = obj.area.y * rs
+        if scaled and rs != 1.0:
+            w, h = surf.get_size()
+            surf = pygame.transform.scale(surf, (int(w * rs), int(h * rs)))
+        return surf, x, y
 
     def get_object_surfaces(
-        self, layer_id_or_name: Union[int, str], *, copy_surface: bool = True
-    ) -> List[Tuple[Surface, int, int, int]]:
+        self, layer_id_or_name: Union[int, str], *, copy_surface: bool = True, scaled: bool = False
+    ) -> List[Tuple[Surface, float, float, int]]:
         layer = self.get_layer(layer_id_or_name)
         if layer is None or layer.layer_type != "object":
             return []
-        result: List[Tuple[Surface, int, int, int]] = []
+        result: List[Tuple[Surface, float, float, int]] = []
+        rs = self.render_scale if scaled else 1.0
         for oid, obj in layer.objects.items():
             surf = self.get_object_surface(obj, copy_surface=copy_surface)
             if surf is not None:
-                result.append((surf, obj.area.x, obj.area.y, oid))
+                x = obj.area.x * rs
+                y = obj.area.y * rs
+                if scaled and rs != 1.0:
+                    w, h = surf.get_size()
+                    surf = pygame.transform.scale(surf, (int(w * rs), int(h * rs)))
+                result.append((surf, x, y, oid))
         return result
 
     def get_tileset_animation(self, ttype: int) -> Optional[dict]:

{tilemap_parser-4.2.4 → tilemap_parser-4.2.6}/src/tilemap_parser/runtime/map_object.py

@@ -63,8 +63,8 @@ class MapObject:
         self,
         x: float,
         y: float,
-        surface: Surface,
-        collision_shape: CollisionPolygon,
+        surface: Optional[Surface] = None,
+        collision_shape: Optional[CollisionPolygon] = None,
         *,
         collision_shapes: Optional[List[CollisionPolygon]] = None,
         collision_layer: int = 1,
@@ -74,12 +74,23 @@ class MapObject:
         self.x = x
         self.y = y
         self.surface = surface
-        self.collision_shapes = collision_shapes or [collision_shape]
-        self.collision_shape = self.collision_shapes[0]
+        if collision_shapes is not None:
+            self.collision_shapes = collision_shapes
+            self.collision_shape = collision_shapes[0] if collision_shapes else None
+        elif collision_shape is not None:
+            self.collision_shapes = [collision_shape]
+            self.collision_shape = collision_shape
+        else:
+            self.collision_shapes = []
+            self.collision_shape = None
         self.collision_layer = collision_layer
         self.collision_mask = collision_mask
         self.y_sort_origin = y_sort_origin
 
+    @property
+    def has_collision(self) -> bool:
+        return len(self.collision_shapes) > 0
+
 
 def _resolve_object_collision_filename(tileset_path: Union[str, Path]) -> str:
     """Extract the object collision filename for a given tileset path.
@@ -94,8 +105,9 @@ def load_map_objects(
     collision_dir: Union[str, Path],
     *,
     cache: Optional[CollisionCache] = None,
+    require_collision: bool = True,
 ) -> List[MapObject]:
-    """Load all collidable objects from a tilemap.
+    """Load objects from a tilemap.
 
     Iterates every object layer in *tilemap_data*, resolves the
     corresponding ``.object_collision.json`` from *collision_dir*, and
@@ -129,13 +141,12 @@ def load_map_objects(
             files (typically ``<map_path>/collision/``).
         cache: Optional :class:`CollisionCache` for caching parsed
             collision data across calls.
+        require_collision: If True (default), only objects with matching
+            collision regions are returned. If False, visual-only objects
+            without collision are also included.
 
     Returns:
-        List of :class:`MapObject` instances, one per map object that
-        has both a valid surface and a matching collision region.
-        When a region contains multiple collision polygons, all shapes
-        are preserved in :attr:`MapObject.collision_shapes` and the
-        collision system checks each shape pair during narrowphase.
+        List of :class:`MapObject` instances.
     """
     collision_dir = Path(collision_dir)
     objects: List[MapObject] = []
@@ -167,6 +178,16 @@ def load_map_objects(
 
             collision_data = loaded_collision[ttype]
             if collision_data is None:
+                if require_collision:
+                    continue
+                game_obj = MapObject(
+                    x=x,
+                    y=y,
+                    surface=surf,
+                    collision_shape=None,
+                    collision_shapes=[],
+                )
+                objects.append(game_obj)
                 continue
 
             world_shapes = []
@@ -180,6 +201,16 @@ def load_map_objects(
                 oy = region.region_rect[1] * rs
                 world_shapes.extend(shape.transform(ox, oy, rs) for shape in region.shapes)
             if not world_shapes:
+                if require_collision:
+                    continue
+                game_obj = MapObject(
+                    x=x,
+                    y=y,
+                    surface=surf,
+                    collision_shape=None,
+                    collision_shapes=[],
+                )
+                objects.append(game_obj)
                 continue
 
             game_obj = MapObject(

{tilemap_parser-4.2.4 → tilemap_parser-4.2.6}/src/tilemap_parser/runtime/renderer.py

@@ -178,6 +178,8 @@ class TileLayerRenderer:
                         tile_iter = sorted(chunk, key=lambda p: p[1] * self._eff_h + origin)
 
                     for x, y in tile_iter:
+                        if not (min_x <= x <= max_x and min_y <= y <= max_y):
+                            continue
                         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)

{tilemap_parser-4.2.4 → tilemap_parser-4.2.6}/src/tilemap_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 4.2.4
+Version: 4.2.6
 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-4.2.4 → tilemap_parser-4.2.6}/tests/test_map_loader.py

@@ -346,3 +346,102 @@ class TestNodeLoading:
         assert pe.config.lifetime_min == 0.5
         assert pe.config.lifetime_max == 2.0
         assert pe.config.gravity_y == 30.0
+
+    def test_get_object_surfaces_scaled(self, map_data):
+        _, data_dir, _, _ = map_data
+        # Create map with render_scale = 2.0 and object layer
+        map_path = data_dir / "test_map_obj.json"
+        payload = {
+            "meta": {
+                "tile_size": "16;16",
+                "map_size": "10;10",
+                "version": "1.1",
+                "render_scale": 2.0,
+            },
+            "resources": {"tilesets": [{"path": "../assets/tileset.png", "type": "object"}]},
+            "project_state": {"rules": [], "groups": []},
+            "data": {
+                "ongrid": {},
+                "layers": [
+                    {
+                        "name": "Obj",
+                        "type": "object",
+                        "visible": True,
+                        "locked": False,
+                        "opacity": 1.0,
+                        "z_index": 0,
+                        "properties": {},
+                        "tiles": {},
+                        "objects": {
+                            "1": {
+                                "area": {"x": 32, "y": 64, "w": 16, "h": 16},
+                                "ttype": 0,
+                                "tileset_type": "object",
+                                "variant": 0,
+                                "properties": {},
+                            }
+                        },
+                    }
+                ],
+            },
+        }
+        with open(map_path, "w") as f:
+            json.dump(payload, f, indent=2)
+
+        td = TilemapData.load(map_path)
+        # Unscaled
+        unscaled = td.get_object_surfaces("Obj", scaled=False)
+        assert len(unscaled) == 1
+        surf_u, x_u, y_u, _ = unscaled[0]
+        assert (x_u, y_u) == (32, 64)
+        assert surf_u.get_size() == (16, 16)
+
+        # Scaled
+        scaled = td.get_object_surfaces("Obj", scaled=True)
+        assert len(scaled) == 1
+        surf_s, x_s, y_s, _ = scaled[0]
+        assert (x_s, y_s) == (64, 128)
+        assert surf_s.get_size() == (32, 32)
+
+    def test_area_node_scaled(self, map_data):
+        _, data_dir, _, _ = map_data
+        map_path = data_dir / "test_map_scaled_nodes.json"
+        payload = {
+            "meta": {
+                "tile_size": "16;16",
+                "map_size": "10;10",
+                "version": "1.1",
+                "render_scale": 3.0,
+            },
+            "resources": {"tilesets": [{"path": "../assets/tileset.png", "type": "tile"}]},
+            "project_state": {"rules": [], "groups": []},
+            "data": {"ongrid": {}, "layers": []},
+        }
+        with open(map_path, "w") as f:
+            json.dump(payload, f, indent=2)
+
+        nodes_path = data_dir / "test_map_scaled_nodes.nodes.json"
+        nodes_payload = {
+            "nodes": [
+                {
+                    "node_id": "area_1",
+                    "name": "Zone",
+                    "node_type": "area",
+                    "area": {"x": 10, "y": 20, "w": 30, "h": 40},
+                    "layer_name": "main",
+                    "properties": {},
+                    "group": "",
+                }
+            ],
+            "groups": [],
+        }
+        with open(nodes_path, "w") as f:
+            json.dump(nodes_payload, f, indent=2)
+
+        td = TilemapData.load(map_path)
+        assert len(td.area_nodes) == 1
+        an = td.area_nodes[0]
+        assert an.rect == pygame.Rect(30, 60, 90, 120)
+
+
+

{tilemap_parser-4.2.4 → tilemap_parser-4.2.6}/tests/test_map_object.py

@@ -1299,4 +1299,26 @@ class TestLoadMapObjects:
             objects = load_map_objects(td, collision_dir)
             assert objects == []
 
+    def test_load_visual_only_objects(self, map_no_collision_file):
+        td, collision_dir = map_no_collision_file
+        # With require_collision=False, objects without collision files are returned
+        objects = load_map_objects(td, collision_dir, require_collision=False)
+        assert len(objects) == 1
+        obj = objects[0]
+        assert obj.has_collision is False
+        assert obj.collision_shape is None
+        assert obj.collision_shapes == []
+        assert isinstance(obj.surface, pygame.Surface)
+
+    def test_map_object_optional_collision(self):
+        surf = pygame.Surface((16, 16))
+        obj = MapObject(x=10, y=20, surface=surf)
+        assert obj.x == 10
+        assert obj.y == 20
+        assert obj.surface is surf
+        assert obj.collision_shape is None
+        assert obj.collision_shapes == []
+        assert obj.has_collision is False
+
+