tilemap-parser 4.2.1__tar.gz → 4.2.3__tar.gz

{tilemap_parser-4.2.1 → tilemap_parser-4.2.3}/PKG-INFO

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

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

@@ -20,6 +20,7 @@ __all__ = [
     "CollisionPolygon",
     "CollisionResult",
     "CollisionRunner",
+    "ICollidable",
     "ICollidableObject",
     "ICollidableSprite",
     "LayerRenderStats",

{tilemap_parser-4.2.1 → tilemap_parser-4.2.3}/src/tilemap_parser/runtime/__init__.py

@@ -18,6 +18,7 @@ from .tile_collision import (
     MovementMode,
     rect_vs_tilemap,
 )
+from .protocols import ICollidable
 from .map_loader import TilemapData, load_map
 from .object_collision import (
     CollisionHit,
@@ -45,6 +46,7 @@ __all__ = [
     "CollisionHit",
     "CollisionResult",
     "CollisionRunner",
+    "ICollidable",
     "ICollidableObject",
     "ICollidableSprite",
     "LayerRenderStats",

{tilemap_parser-4.2.1 → tilemap_parser-4.2.3}/src/tilemap_parser/runtime/map_object.py

@@ -18,6 +18,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import Dict, List, Optional, Union
 
+import pygame
 from pygame import Surface
 
 from ..parser.collision import CollisionPolygon, ObjectCollisionData
@@ -31,6 +32,12 @@ class MapObject:
     A game object loaded from a tilemap, carrying a surface for
     rendering and collision data for physics.
 
+    All spatial data (``x``, ``y``, ``surface`` size, and collision
+    polygon vertices) is pre-scaled by the map's ``render_scale``.
+    Units are in *effective* pixels (``render_scale × tile_size``).
+    The object is ready for direct use in a game loop that runs in
+    effective-pixel space — no additional scaling needed.
+
     Satisfies the :class:`ICollidableObject` protocol so it can be
     added directly to an :class:`ObjectCollisionManager`.
 
@@ -89,9 +96,26 @@ def load_map_objects(
 
     Iterates every object layer in *tilemap_data*, resolves the
     corresponding ``.object_collision.json`` from *collision_dir*, and
-    builds :class:`MapObject` instances with surfaces, owner-local
-    collision shapes (region offset only; consumers add x/y), and
-    layer/mask values from the collision regions.
+    builds :class:`MapObject` instances with pre-scaled surfaces,
+    positions, and collision shapes.
+
+    **render_scale transparency**
+
+    All spatial data is automatically scaled by the map's
+    ``render_scale`` (from ``tilemap_data.render_scale``):
+
+    * ``MapObject.x`` / ``MapObject.y`` — raw map coords × ``rs``
+      (stored as ``float``; fractional pixel positions are preserved).
+    * ``MapObject.surface`` — surface is scaled by ``rs`` via
+      :func:`pygame.transform.scale` (no-op when ``rs == 1.0``).
+      Raster dimensions are truncated to integers via ``int()``
+      to satisfy :func:`pygame.transform.scale` requirements.
+    * Collision polygon vertices and ``region_rect`` offsets are
+      multiplied by ``rs`` via :meth:`CollisionPolygon.transform`.
+
+    The returned objects are ready for a game loop that runs in
+    effective-pixel space (``render_scale × tile_size``).  No
+    additional scaling is required by the caller.
 
     Collision data is cached per tileset index so the same file is
     never loaded twice.
@@ -123,6 +147,13 @@ def load_map_objects(
                 continue
 
             surf, x, y = surf_x_y
+            rs = tilemap_data.render_scale
+            x = x * rs
+            y = y * rs
+
+            if rs != 1.0 and surf is not None:
+                w, h = surf.get_size()
+                surf = pygame.transform.scale(surf, (int(w * rs), int(h * rs)))
 
             ttype = obj.ttype
             if ttype not in loaded_collision:
@@ -142,9 +173,9 @@ def load_map_objects(
                 if not world_shapes:
                     region_layer = region.collision_layer
                     region_mask = region.collision_mask
-                ox = region.region_rect[0]
-                oy = region.region_rect[1]
-                world_shapes.extend(shape.transform(ox, oy) for shape in region.shapes)
+                ox = region.region_rect[0] * rs
+                oy = region.region_rect[1] * rs
+                world_shapes.extend(shape.transform(ox, oy, rs) for shape in region.shapes)
             if not world_shapes:
                 continue
 

{tilemap_parser-4.2.1 → tilemap_parser-4.2.3}/src/tilemap_parser/runtime/object_collision.py

@@ -33,27 +33,20 @@ from ..utils.geometry import (
     rect_vs_circle,
     rect_vs_rect,
 )
+from .protocols import ICollidable
 
 
-class ICollidableObject(Protocol):
+class ICollidableObject(ICollidable, Protocol):
     """
     Protocol for objects that can collide.
 
-    Required attributes:
-        x: World X position
-        y: World Y position
-        collision_shape: Shape for collision
-            (RectangleShape, CircleShape, CapsuleShape, or CollisionPolygon)
+    All required attributes (x, y, collision_shape) are inherited from ICollidable.
 
     Optional attributes (with defaults):
         collision_layer: Layer this object is on (default: 1)
         collision_mask: Layers to collide with (default: 0xFFFFFFFF)
     """
 
-    x: float
-    y: float
-    collision_shape: Union[RectangleShape, CircleShape, CapsuleShape, CollisionPolygon]
-
 
 @dataclass(slots=True)
 class CollisionHit:

tilemap_parser-4.2.3/src/tilemap_parser/runtime/protocols.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Protocol, Union
+
+from ..parser.collision import (
+    CapsuleShape,
+    CircleShape,
+    CollisionPolygon,
+    RectangleShape,
+)
+
+
+class ICollidable(Protocol):
+    """Base protocol for anything with a world position and collision shape.
+
+    This is the minimal interface for participating in collision detection.
+    All collidable protocols (ICollidableSprite, ICollidableObject) extend this.
+
+    Required attributes:
+        x (float): World X position
+        y (float): World Y position
+        collision_shape: Shape used for collision detection
+            (RectangleShape, CircleShape, CapsuleShape, or CollisionPolygon)
+    """
+
+    x: float
+    y: float
+    collision_shape: Union[RectangleShape, CircleShape, CapsuleShape, CollisionPolygon]

{tilemap_parser-4.2.1 → tilemap_parser-4.2.3}/src/tilemap_parser/runtime/tile_collision.py

@@ -23,12 +23,13 @@ from ..parser.collision import (
     RectangleShape,
     TilesetCollision,
 )
+from .protocols import ICollidable
 
 Point = Tuple[float, float]
 Vector2 = Tuple[float, float]
 
 
-class ICollidableSprite(Protocol):
+class ICollidableSprite(ICollidable, Protocol):
     """
     Interface that any sprite/character class must implement to use collision runners.
 
@@ -303,7 +304,7 @@ def _circle_polygon_collision_offset(
     return False
 
 
-def get_shape_bounds(sprite: ICollidableSprite) -> Tuple[float, float, float, float]:
+def get_shape_bounds(sprite: ICollidable) -> Tuple[float, float, float, float]:
     """Get AABB bounds for sprite (left, top, right, bottom)"""
     shape = sprite.collision_shape
     if isinstance(shape, RectangleShape):
@@ -328,7 +329,7 @@ def get_shape_bounds(sprite: ICollidableSprite) -> Tuple[float, float, float, fl
 
 
 def check_sprite_polygon_collision(
-    sprite: ICollidableSprite, polygon: CollisionPolygon
+    sprite: ICollidable, polygon: CollisionPolygon
 ) -> bool:
     """Check if sprite collides with a world-space polygon (legacy / public API)."""
     shape = sprite.collision_shape
@@ -349,7 +350,7 @@ def check_sprite_polygon_collision(
 
 
 def _check_sprite_polygon_offset(
-    sprite: ICollidableSprite,
+    sprite: ICollidable,
     polygon: CollisionPolygon,
     ox: float,
     oy: float,
@@ -489,7 +490,7 @@ class CollisionRunner:
         self,
         tileset_collision: TilesetCollision,
         tile_map: dict,
-        sprite: ICollidableSprite,
+        sprite: ICollidable,
         margin: int = 1,
     ) -> List[CollisionPolygon]:
         """
@@ -529,7 +530,7 @@ class CollisionRunner:
 
     def _collides_at(
         self,
-        sprite: ICollidableSprite,
+        sprite: ICollidable,
         tileset_collision: TilesetCollision,
         tile_map: dict,
         margin: int = 1,
@@ -567,7 +568,7 @@ class CollisionRunner:
 
     def _first_colliding_shape(
         self,
-        sprite: ICollidableSprite,
+        sprite: ICollidable,
         tileset_collision: TilesetCollision,
         tile_map: dict,
         margin: int = 1,
@@ -603,7 +604,7 @@ class CollisionRunner:
 
     def move_and_slide(
         self,
-        sprite: ICollidableSprite,
+        sprite: ICollidable,
         tileset_collision: TilesetCollision,
         tile_map: dict,
         delta_x: float,
@@ -729,7 +730,7 @@ class CollisionRunner:
 
     def _get_collision_normal_from_motion(
         self,
-        sprite: ICollidableSprite,
+        sprite: ICollidable,
         polygon: CollisionPolygon,
         ox: float,
         oy: float,
@@ -1745,7 +1746,7 @@ class CollisionRunner:
 
     def move_rpg(
         self,
-        sprite: ICollidableSprite,
+        sprite: ICollidable,
         tileset_collision: TilesetCollision,
         tile_map: dict,
         delta_x: float,
@@ -1814,7 +1815,7 @@ class CollisionRunner:
 
     def move(
         self,
-        sprite: ICollidableSprite,
+        sprite: ICollidable,
         tileset_collision: TilesetCollision,
         tile_map: dict,
         delta_x: float = 0.0,

{tilemap_parser-4.2.1 → tilemap_parser-4.2.3}/src/tilemap_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 4.2.1
+Version: 4.2.3
 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.1 → tilemap_parser-4.2.3}/src/tilemap_parser.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ src/tilemap_parser/runtime/map_loader.py
 src/tilemap_parser/runtime/map_object.py
 src/tilemap_parser/runtime/object_collision.py
 src/tilemap_parser/runtime/particles.py
+src/tilemap_parser/runtime/protocols.py
 src/tilemap_parser/runtime/renderer.py
 src/tilemap_parser/runtime/tile_collision.py
 src/tilemap_parser/utils/__init__.py

{tilemap_parser-4.2.1 → tilemap_parser-4.2.3}/tests/test_map_object.py

@@ -652,6 +652,601 @@ class TestLoadMapObjects:
             hit = check_collision(loaded, manual)
             assert hit is not None, "loaded and manual object at same world pos should collide"
 
+    def test_default_scale_no_op(self, basic_map):
+        """render_scale=1.0 (default) behaves identically to before."""
+        td, collision_dir, _ = basic_map
+        assert td.render_scale == 1.0
+        objects = load_map_objects(td, collision_dir)
+        assert len(objects) == 1
+        obj = objects[0]
+        # Positions are raw (no scaling)
+        assert obj.x == 100
+        assert obj.y == 200
+        # Vertices are raw
+        verts = obj.collision_shape.vertices
+        assert verts[0] == (0, 0)
+        assert verts[1] == (16, 0)
+        assert verts[2] == (16, 16)
+        assert verts[3] == (0, 16)
+
+    def test_render_scale_3x(self):
+        """render_scale=3.0 scales positions and polygon vertices."""
+        from tilemap_parser.runtime.map_object import load_map_objects
+        from tilemap_parser.runtime.map_loader import TilemapData
+
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp = Path(tmp)
+            assets_dir = tmp / "assets"
+            data_dir = tmp / "data"
+            collision_dir = tmp / "data" / "collision"
+            assets_dir.mkdir(parents=True)
+            data_dir.mkdir(parents=True)
+            collision_dir.mkdir(parents=True)
+
+            png = assets_dir / "tileset.png"
+            _make_minimal_png(png, (32, 16))
+
+            collision_payload = {
+                "tileset_name": "tileset",
+                "regions": {
+                    "region_r": {
+                        "region_id": "region_r",
+                        "region_rect": [5, 10, 16, 16],
+                        "name": "R",
+                        "shapes": [{"type": "polygon", "vertices": [[0, 0], [16, 0], [16, 16], [0, 16]], "one_way": False}],
+                        "properties": {},
+                    },
+                },
+            }
+            coll_path = collision_dir / "tileset.object_collision.json"
+            with open(coll_path, "w") as f:
+                json.dump(collision_payload, f, indent=2)
+
+            # Map with render_scale=3.0
+            payload = {
+                "meta": {
+                    "tile_size": "16;16",
+                    "map_size": "10;10",
+                    "version": "1.1",
+                    "render_scale": 3.0,
+                },
+                "resources": {"tilesets": [{"path": "../assets/tileset.png", "type": "object"}]},
+                "project_state": {"rules": [], "groups": []},
+                "data": {
+                    "ongrid": {},
+                    "layers": [
+                        {
+                            "name": "Object Layer",
+                            "type": "object",
+                            "visible": True,
+                            "locked": False,
+                            "opacity": 1.0,
+                            "z_index": 0,
+                            "properties": {},
+                            "tiles": {},
+                            "objects": {
+                                "1": {
+                                    "area": {"x": 100, "y": 200, "w": 16, "h": 16},
+                                    "ttype": 0,
+                                    "tileset_type": "object",
+                                    "variant": 0,
+                                    "properties": {},
+                                },
+                            },
+                            "next_object_id": 2,
+                        },
+                    ],
+                },
+            }
+            map_path = data_dir / "test_map.json"
+            with open(map_path, "w") as f:
+                json.dump(payload, f, indent=2)
+
+            td = TilemapData.load(map_path)
+            assert td.render_scale == 3.0
+            objects = load_map_objects(td, collision_dir)
+            assert len(objects) == 1
+            obj = objects[0]
+
+            # Position scaled by 3x
+            assert obj.x == 300  # 100 * 3
+            assert obj.y == 600  # 200 * 3
+
+            # region_rect [5, 10] scaled by 3x → ox=15, oy=30
+            # Vertices scaled by 3x: (0,0)→(0,0), (16,0)→(48,0), (16,16)→(48,48), (0,16)→(0,48)
+            # World = ox + vx*rs: (15+0, 30+0) = (15, 30)
+            #                     (15+48, 30+0) = (63, 30)
+            #                     (15+48, 30+48) = (63, 78)
+            #                     (15+0, 30+48) = (15, 78)
+            verts = obj.collision_shape.vertices
+            assert len(verts) == 4
+            assert verts[0] == pytest.approx((15.0, 30.0))
+            assert verts[1] == pytest.approx((63.0, 30.0))
+            assert verts[2] == pytest.approx((63.0, 78.0))
+            assert verts[3] == pytest.approx((15.0, 78.0))
+
+            # Surface scaled by 3x: tileset is 32×16, variant 0 is 16×16
+            assert obj.surface.get_size() == (48, 48)  # 16*3, 16*3
+
+    def test_render_scale_surface_scaled(self):
+        """Surface is scaled by render_scale in load_map_objects."""
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp = Path(tmp)
+            assets_dir = tmp / "assets"
+            data_dir = tmp / "data"
+            collision_dir = tmp / "data" / "collision"
+            assets_dir.mkdir(parents=True)
+            data_dir.mkdir(parents=True)
+            collision_dir.mkdir(parents=True)
+
+            png = assets_dir / "tileset.png"
+            # Create a 64×32 tileset with 2 variants (16×16 each)
+            surf = pygame.Surface((64, 32))
+            surf.fill((255, 0, 255))
+            pygame.image.save(surf, str(png))
+
+            collision_payload = {
+                "tileset_name": "tileset",
+                "regions": {
+                    "region_r": {
+                        "region_id": "region_r",
+                        "region_rect": [0, 0, 16, 16],
+                        "name": "R",
+                        "shapes": [{"type": "polygon", "vertices": [[0, 0], [16, 0], [16, 16], [0, 16]], "one_way": False}],
+                        "properties": {},
+                    },
+                },
+            }
+            coll_path = collision_dir / "tileset.object_collision.json"
+            with open(coll_path, "w") as f:
+                json.dump(collision_payload, f, indent=2)
+
+            for rs_val, expected_w, expected_h in [(1.0, 16, 16), (2.0, 32, 32), (3.0, 48, 48), (1.5, 24, 24)]:
+                payload = {
+                    "meta": {
+                        "tile_size": "16;16",
+                        "map_size": "10;10",
+                        "version": "1.1",
+                        "render_scale": rs_val,
+                    },
+                    "resources": {"tilesets": [{"path": "../assets/tileset.png", "type": "object"}]},
+                    "project_state": {"rules": [], "groups": []},
+                    "data": {
+                        "ongrid": {},
+                        "layers": [
+                            {
+                                "name": "Object Layer",
+                                "type": "object",
+                                "visible": True,
+                                "locked": False,
+                                "opacity": 1.0,
+                                "z_index": 0,
+                                "properties": {},
+                                "tiles": {},
+                                "objects": {
+                                    "1": {
+                                        "area": {"x": 10, "y": 20, "w": 16, "h": 16},
+                                        "ttype": 0,
+                                        "tileset_type": "object",
+                                        "variant": 0,
+                                        "properties": {},
+                                    },
+                                },
+                                "next_object_id": 2,
+                            },
+                        ],
+                    },
+                }
+                map_path = data_dir / "test_map.json"
+                with open(map_path, "w") as f:
+                    json.dump(payload, f, indent=2)
+
+                td = TilemapData.load(map_path)
+                objects = load_map_objects(td, collision_dir)
+                assert len(objects) == 1
+                obj = objects[0]
+                assert obj.surface.get_size() == (expected_w, expected_h), \
+                    f"rs={rs_val}: expected ({expected_w},{expected_h}) got {obj.surface.get_size()}"
+                assert obj.x == 10 * rs_val, f"rs={rs_val}: x={obj.x} != {10 * rs_val}"
+                assert obj.y == 20 * rs_val, f"rs={rs_val}: y={obj.y} != {20 * rs_val}"
+
+            # Fractional rs with odd dimensions to exercise surface truncation
+            odd_png = assets_dir / "odd_tileset.png"
+            odd_surf = pygame.Surface((17, 35))
+            odd_surf.fill((0, 255, 0))
+            pygame.image.save(odd_surf, str(odd_png))
+
+            odd_collision = {
+                "tileset_name": "odd_tileset",
+                "regions": {
+                    "region_r": {
+                        "region_id": "region_r",
+                        "region_rect": [0, 0, 17, 35],
+                        "name": "R",
+                        "shapes": [{"type": "polygon", "vertices": [[0, 0], [17, 0], [17, 35], [0, 35]], "one_way": False}],
+                        "properties": {},
+                    },
+                },
+            }
+            odd_coll_path = collision_dir / "odd_tileset.object_collision.json"
+            with open(odd_coll_path, "w") as f:
+                json.dump(odd_collision, f, indent=2)
+
+            payload_odd = {
+                "meta": {
+                    "tile_size": "16;16",
+                    "map_size": "10;10",
+                    "version": "1.1",
+                    "render_scale": 1.5,
+                },
+                "resources": {"tilesets": [{"path": "../assets/odd_tileset.png", "type": "object"}]},
+                "project_state": {"rules": [], "groups": []},
+                "data": {
+                    "ongrid": {},
+                    "layers": [
+                        {
+                            "name": "Object Layer",
+                            "type": "object",
+                            "visible": True,
+                            "locked": False,
+                            "opacity": 1.0,
+                            "z_index": 0,
+                            "properties": {},
+                            "tiles": {},
+                            "objects": {
+                                "1": {
+                                    "area": {"x": 11, "y": 21, "w": 17, "h": 35},
+                                    "ttype": 0,
+                                    "tileset_type": "object",
+                                    "variant": 0,
+                                    "properties": {},
+                                },
+                            },
+                            "next_object_id": 2,
+                        },
+                    ],
+                },
+            }
+            odd_map_path = data_dir / "odd_test_map.json"
+            with open(odd_map_path, "w") as f:
+                json.dump(payload_odd, f, indent=2)
+
+            td_odd = TilemapData.load(odd_map_path)
+            objects_odd = load_map_objects(td_odd, collision_dir)
+            assert len(objects_odd) == 1
+            obj = objects_odd[0]
+            assert obj.x == 11 * 1.5, f"fractional x: {obj.x} != {11 * 1.5}"
+            assert obj.y == 21 * 1.5, f"fractional y: {obj.y} != {21 * 1.5}"
+            assert obj.surface.get_size() == (25, 52), \
+                f"truncated surface: {obj.surface.get_size()} != (25, 52)  [int(17*1.5)=25, int(35*1.5)=52]"
+
+    def test_render_scale_collision_consistency(self):
+        """At render_scale=3.0, a loaded object collides with a manually-placed
+        probe object if and only if they overlap in effective (scaled) space."""
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp = Path(tmp)
+            assets_dir = tmp / "assets"
+            data_dir = tmp / "data"
+            collision_dir = tmp / "data" / "collision"
+            assets_dir.mkdir(parents=True)
+            data_dir.mkdir(parents=True)
+            collision_dir.mkdir(parents=True)
+
+            png = assets_dir / "tileset.png"
+            _make_minimal_png(png, (32, 16))
+
+            # Collision region at (0,0) with a 16x16 square polygon
+            collision_payload = {
+                "tileset_name": "tileset",
+                "regions": {
+                    "region_r": {
+                        "region_id": "region_r",
+                        "region_rect": [0, 0, 16, 16],
+                        "name": "R",
+                        "shapes": [{"type": "polygon", "vertices": [[0, 0], [16, 0], [16, 16], [0, 16]], "one_way": False}],
+                        "properties": {},
+                    },
+                },
+            }
+            coll_path = collision_dir / "tileset.object_collision.json"
+            with open(coll_path, "w") as f:
+                json.dump(collision_payload, f, indent=2)
+
+            payload = {
+                "meta": {
+                    "tile_size": "16;16",
+                    "map_size": "10;10",
+                    "version": "1.1",
+                    "render_scale": 3.0,
+                },
+                "resources": {"tilesets": [{"path": "../assets/tileset.png", "type": "object"}]},
+                "project_state": {"rules": [], "groups": []},
+                "data": {
+                    "ongrid": {},
+                    "layers": [
+                        {
+                            "name": "Object Layer",
+                            "type": "object",
+                            "visible": True,
+                            "locked": False,
+                            "opacity": 1.0,
+                            "z_index": 0,
+                            "properties": {},
+                            "tiles": {},
+                            "objects": {
+                                "1": {
+                                    "area": {"x": 100, "y": 200, "w": 16, "h": 16},
+                                    "ttype": 0,
+                                    "tileset_type": "object",
+                                    "variant": 0,
+                                    "properties": {},
+                                },
+                            },
+                            "next_object_id": 2,
+                        },
+                    ],
+                },
+            }
+            map_path = data_dir / "test_map.json"
+            with open(map_path, "w") as f:
+                json.dump(payload, f, indent=2)
+
+            td = TilemapData.load(map_path)
+            objects = load_map_objects(td, collision_dir)
+            assert len(objects) == 1
+            loaded = objects[0]
+
+            # Loaded object position = (300, 600) in effective space
+            # Collision polygon covers (300, 600) to (300+48, 600+48) = (348, 648)
+            assert loaded.x == 300
+            assert loaded.y == 600
+
+            # Probe at (310, 610) with a 16x16 rect in effective space must collide
+            probe_surf = pygame.Surface((16, 16))
+            probe_shape = CollisionPolygon(vertices=[(0, 0), (16, 0), (16, 16), (0, 16)])
+            probe = MapObject(x=310, y=610, surface=probe_surf, collision_shape=probe_shape)
+
+            from tilemap_parser.runtime.object_collision import check_collision
+
+            hit = check_collision(loaded, probe)
+            assert hit is not None, "expected collision in effective space"
+
+            # Probe far away must NOT collide
+            probe_far = MapObject(x=1000, y=1000, surface=probe_surf, collision_shape=probe_shape)
+            hit_far = check_collision(loaded, probe_far)
+            assert hit_far is None, "no collision expected for far probe"
+
+    def test_render_scale_region_offset_scaled(self):
+        """Non-zero region_rect offset is scaled by render_scale."""
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp = Path(tmp)
+            assets_dir = tmp / "assets"
+            data_dir = tmp / "data"
+            collision_dir = tmp / "data" / "collision"
+            assets_dir.mkdir(parents=True)
+            data_dir.mkdir(parents=True)
+            collision_dir.mkdir(parents=True)
+
+            png = assets_dir / "tileset.png"
+            _make_minimal_png(png, (32, 16))
+
+            # region_rect offset of (5,10), polygon at origin within that region
+            collision_payload = {
+                "tileset_name": "tileset",
+                "regions": {
+                    "region_r": {
+                        "region_id": "region_r",
+                        "region_rect": [5, 10, 16, 16],
+                        "name": "R",
+                        "shapes": [{"type": "polygon", "vertices": [[0, 0], [8, 0], [8, 8], [0, 8]], "one_way": False}],
+                        "properties": {},
+                    },
+                },
+            }
+            coll_path = collision_dir / "tileset.object_collision.json"
+            with open(coll_path, "w") as f:
+                json.dump(collision_payload, f, indent=2)
+
+            payload = {
+                "meta": {
+                    "tile_size": "16;16",
+                    "map_size": "10;10",
+                    "version": "1.1",
+                    "render_scale": 3.0,
+                },
+                "resources": {"tilesets": [{"path": "../assets/tileset.png", "type": "object"}]},
+                "project_state": {"rules": [], "groups": []},
+                "data": {
+                    "ongrid": {},
+                    "layers": [
+                        {
+                            "name": "Object Layer",
+                            "type": "object",
+                            "visible": True,
+                            "locked": False,
+                            "opacity": 1.0,
+                            "z_index": 0,
+                            "properties": {},
+                            "tiles": {},
+                            "objects": {
+                                "1": {
+                                    "area": {"x": 100, "y": 200, "w": 16, "h": 16},
+                                    "ttype": 0,
+                                    "tileset_type": "object",
+                                    "variant": 0,
+                                    "properties": {},
+                                },
+                            },
+                            "next_object_id": 2,
+                        },
+                    ],
+                },
+            }
+            map_path = data_dir / "test_map.json"
+            with open(map_path, "w") as f:
+                json.dump(payload, f, indent=2)
+
+            td = TilemapData.load(map_path)
+            objects = load_map_objects(td, collision_dir)
+            assert len(objects) == 1
+            obj = objects[0]
+
+            # Position scaled: (300, 600)
+            # region_rect offset scaled: ox=15, oy=30
+            # Vertices scaled: (0,0)→(0,0), (8,0)→(24,0), (8,8)→(24,24), (0,8)→(0,24)
+            # World: (15, 30), (39, 30), (39, 54), (15, 54)
+            verts = obj.collision_shape.vertices
+            assert verts[0] == pytest.approx((15.0, 30.0))
+            assert verts[1] == pytest.approx((39.0, 30.0))
+            assert verts[2] == pytest.approx((39.0, 54.0))
+            assert verts[3] == pytest.approx((15.0, 54.0))
+
+            # Probe at object center must collide
+            probe_surf = pygame.Surface((16, 16))
+            probe_shape = CollisionPolygon(vertices=[(0, 0), (16, 0), (16, 16), (0, 16)])
+            # Loaded world AABB: (300+15, 600+30) to (300+39, 600+54) = (315, 630) to (339, 654)
+            probe = MapObject(x=315, y=630, surface=probe_surf, collision_shape=probe_shape)
+
+            from tilemap_parser.runtime.object_collision import check_collision
+
+            hit = check_collision(obj, probe)
+            assert hit is not None, "expected collision with region offset"
+
+    def test_render_scale_visual_collision_alignment(self):
+        """At render_scale=N, collision AABB is fully inside visual rect
+        and vertex positions are pixel-accurate for known values."""
+        from tilemap_parser.runtime.map_object import load_map_objects
+        from tilemap_parser.runtime.map_loader import TilemapData
+
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp = Path(tmp)
+            assets_dir = tmp / "assets"
+            data_dir = tmp / "data"
+            collision_dir = tmp / "data" / "collision"
+            assets_dir.mkdir(parents=True)
+            data_dir.mkdir(parents=True)
+            collision_dir.mkdir(parents=True)
+
+            # Tileset: 64x96 with a known shape
+            tileset_surf = pygame.Surface((64, 96))
+            tileset_surf.fill((0, 255, 0))
+            png = assets_dir / "tree.png"
+            pygame.image.save(tileset_surf, str(png))
+
+            # Collision: region_rect=[0,3,64,93] with polygon
+            collision_payload = {
+                "tileset_name": "tree",
+                "regions": {
+                    "region_r": {
+                        "region_id": "region_r",
+                        "region_rect": [0, 3, 64, 93],
+                        "name": "R",
+                        "shapes": [
+                            {
+                                "type": "polygon",
+                                "vertices": [[32.0, 2.75], [8.0, 30.0], [10.5, 58.75],
+                                             [22.5, 65.25], [20.0, 88.25], [33.5, 81.75],
+                                             [47.5, 87.75], [41.5, 65.75], [58.5, 48.75],
+                                             [52.0, 25.0]],
+                                "one_way": False,
+                            }
+                        ],
+                        "properties": {"collision_layer": 1, "collision_mask": 65535},
+                    },
+                },
+            }
+            coll_path = collision_dir / "tree.object_collision.json"
+            with open(coll_path, "w") as f:
+                json.dump(collision_payload, f, indent=2)
+
+            for rs_val in [1.0, 2.0, 3.0, 4.0]:
+                payload = {
+                    "meta": {
+                        "tile_size": "16;16",
+                        "map_size": "10;10",
+                        "version": "1.1",
+                        "render_scale": rs_val,
+                    },
+                    "resources": {"tilesets": [{"path": "../assets/tree.png", "type": "object"}]},
+                    "project_state": {"rules": [], "groups": []},
+                    "data": {
+                        "ongrid": {},
+                        "layers": [
+                            {
+                                "name": "Objects",
+                                "type": "object",
+                                "visible": True,
+                                "locked": False,
+                                "opacity": 1.0,
+                                "z_index": 0,
+                                "properties": {},
+                                "tiles": {},
+                                "objects": {
+                                    "1": {
+                                        "area": {"x": 27, "y": 82, "w": 64, "h": 96},
+                                        "ttype": 0,
+                                        "tileset_type": "object",
+                                        "variant": 0,
+                                        "properties": {},
+                                    },
+                                },
+                                "next_object_id": 2,
+                            },
+                        ],
+                    },
+                }
+                map_path = data_dir / "test_map.json"
+                with open(map_path, "w") as f:
+                    json.dump(payload, f, indent=2)
+
+                td = TilemapData.load(map_path)
+                objects = load_map_objects(td, collision_dir)
+                assert len(objects) == 1, f"rs={rs_val}: expected 1 object"
+                obj = objects[0]
+
+                # Verify surface size is pixel-accurate at integer render_scale
+                expected_w = int(64 * rs_val)
+                expected_h = int(96 * rs_val)
+                assert obj.surface.get_size() == (expected_w, expected_h), \
+                    f"rs={rs_val}: surface {obj.surface.get_size()} != ({expected_w},{expected_h})"
+
+                # Verify position is pixel-accurate (float)
+                assert obj.x == 27 * rs_val, f"rs={rs_val}: x={obj.x} != {27 * rs_val}"
+                assert obj.y == 82 * rs_val, f"rs={rs_val}: y={obj.y} != {82 * rs_val}"
+
+                # Verify every collision vertex is pixel-accurate for known values
+                shape = obj.collision_shapes[0]
+                # First vertex: (32.0, 2.75) + region_rect (0, 3) = world (32*rs, (3+2.75)*rs)
+                expected_v0 = (32.0 * rs_val, (3.0 + 2.75) * rs_val)
+                actual_v0 = shape.vertices[0]
+                assert abs(actual_v0[0] - expected_v0[0]) < 0.001, \
+                    f"rs={rs_val}: vertex[0].x {actual_v0[0]} != {expected_v0[0]}"
+                assert abs(actual_v0[1] - expected_v0[1]) < 0.001, \
+                    f"rs={rs_val}: vertex[0].y {actual_v0[1]} != {expected_v0[1]}"
+
+                # Verify collision AABB is inside visual rect
+                xs = [v[0] for v in shape.vertices]
+                ys = [v[1] for v in shape.vertices]
+                coll_min_x = obj.x + min(xs)
+                coll_max_x = obj.x + max(xs)
+                coll_min_y = obj.y + min(ys)
+                coll_max_y = obj.y + max(ys)
+
+                vis_left = obj.x
+                vis_top = obj.y
+                vis_right = obj.x + expected_w
+                vis_bottom = obj.y + expected_h
+
+                margin = -0.001  # allow 0px floating point tolerance
+                assert coll_min_x >= vis_left + margin, \
+                    f"rs={rs_val}: collision left {coll_min_x} < visual left {vis_left}"
+                assert coll_min_y >= vis_top + margin, \
+                    f"rs={rs_val}: collision top {coll_min_y} < visual top {vis_top}"
+                assert coll_max_x <= vis_right - margin, \
+                    f"rs={rs_val}: collision right {coll_max_x} > visual right {vis_right}"
+                assert coll_max_y <= vis_bottom - margin, \
+                    f"rs={rs_val}: collision bottom {coll_max_y} > visual bottom {vis_bottom}"
+
     def test_invalid_tileset_index_skipped(self):
         """Object with ttype out of range is skipped."""
         with tempfile.TemporaryDirectory() as tmp: