tilemap-parser 3.0.0__tar.gz → 3.1.1__tar.gz

{tilemap_parser-3.0.0 → tilemap_parser-3.1.1}/PKG-INFO

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

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

@@ -2,7 +2,7 @@
 Object-to-object collision detection runtime.
 
 Provides a protocol-based interface, shape dispatch, layer filtering,
-a multi-object manager, and collision hit helpers for separation/resolve.
+a multi-object manager, and collision hit helpers for separation/resolve/slide.
 """
 
 from __future__ import annotations
@@ -72,6 +72,30 @@ class CollisionHit:
         self.object_b.x += sep_x
         self.object_b.y += sep_y
 
+    def slide_velocity(self, vx: float, vy: float) -> tuple[float, float]:
+        """Project velocity along the collision surface (slide response).
+
+        Removes the component of (vx, vy) that is along *self.normal*,
+        leaving only the tangential component.  Intended for the moving
+        object passed as *object_a* — when that object moves into
+        *object_b* the approach component is stripped so the object slides
+        along the surface instead of penetrating.
+
+        If the velocity is already parallel to the surface or points away
+        from *object_b* the original velocity is returned unchanged.
+
+        Args:
+            vx: X component of velocity (object_a's velocity)
+            vy: Y component of velocity
+
+        Returns:
+            (slide_x, slide_y) — velocity projected onto the surface
+        """
+        dot = vx * self.normal[0] + vy * self.normal[1]
+        if dot > 0:
+            return (vx - self.normal[0] * dot, vy - self.normal[1] * dot)
+        return (vx, vy)
+
     def involves(self, obj: ICollidableObject) -> bool:
         """Check if this hit involves the given object."""
         return self.object_a is obj or self.object_b is obj

{tilemap_parser-3.0.0 → tilemap_parser-3.1.1}/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(

{tilemap_parser-3.0.0 → tilemap_parser-3.1.1}/src/tilemap_parser/runtime/tile_collision.py

@@ -71,14 +71,14 @@ def point_in_polygon(point: Point, vertices: List[Point]) -> bool:
     return inside
 
 
-def _point_in_polygon_offset(px: float, py: float, vertices: List[Point], ox: float, oy: float) -> bool:
+def _point_in_polygon_offset(px: float, py: float, vertices: List[Point], ox: float, oy: float, scale: float = 1.0) -> bool:
     """Ray-cast with tile offset applied inline — no allocation."""
     n = len(vertices)
     inside = False
-    p1x, p1y = vertices[0][0] + ox, vertices[0][1] + oy
+    p1x, p1y = vertices[0][0] * scale + ox, vertices[0][1] * scale + oy
     for i in range(1, n + 1):
         vx, vy = vertices[i % n]
-        p2x, p2y = vx + ox, vy + oy
+        p2x, p2y = vx * scale + ox, vy * scale + oy
         if py > min(p1y, p2y):
             if py <= max(p1y, p2y):
                 if px <= max(p1x, p2x):
@@ -123,16 +123,16 @@ def rect_polygon_collision(
 
 def _rect_polygon_collision_offset(
     rect_x: float, rect_y: float, rect_w: float, rect_h: float,
-    vertices: List[Point], ox: float, oy: float,
+    vertices: List[Point], ox: float, oy: float, scale: float = 1.0,
 ) -> bool:
     """Rectangle vs polygon with tile offset applied inline — no allocation."""
     # AABB pre-reject with offset
     n = len(vertices)
-    v0x, v0y = vertices[0][0] + ox, vertices[0][1] + oy
+    v0x, v0y = vertices[0][0] * scale + ox, vertices[0][1] * scale + oy
     min_vx = max_vx = v0x
     min_vy = max_vy = v0y
     for i in range(1, n):
-        wx, wy = vertices[i][0] + ox, vertices[i][1] + oy
+        wx, wy = vertices[i][0] * scale + ox, vertices[i][1] * scale + oy
         if wx < min_vx: min_vx = wx
         elif wx > max_vx: max_vx = wx
         if wy < min_vy: min_vy = wy
@@ -142,14 +142,14 @@ def _rect_polygon_collision_offset(
 
     # Corner tests
     rx2, ry2 = rect_x + rect_w, rect_y + rect_h
-    if _point_in_polygon_offset(rect_x, rect_y,  vertices, ox, oy): return True
-    if _point_in_polygon_offset(rx2,    rect_y,  vertices, ox, oy): return True
-    if _point_in_polygon_offset(rect_x, ry2,     vertices, ox, oy): return True
-    if _point_in_polygon_offset(rx2,    ry2,     vertices, ox, oy): return True
+    if _point_in_polygon_offset(rect_x, rect_y,  vertices, ox, oy, scale): return True
+    if _point_in_polygon_offset(rx2,    rect_y,  vertices, ox, oy, scale): return True
+    if _point_in_polygon_offset(rect_x, ry2,     vertices, ox, oy, scale): return True
+    if _point_in_polygon_offset(rx2,    ry2,     vertices, ox, oy, scale): return True
 
     # Vertex-in-rect
     for vx, vy in vertices:
-        wx, wy = vx + ox, vy + oy
+        wx, wy = vx * scale + ox, vy * scale + oy
         if rect_x <= wx <= rx2 and rect_y <= wy <= ry2:
             return True
     return False
@@ -184,15 +184,15 @@ def circle_polygon_collision(
 
 
 def _circle_polygon_collision_offset(
-    cx: float, cy: float, radius: float, vertices: List[Point], ox: float, oy: float,
+    cx: float, cy: float, radius: float, vertices: List[Point], ox: float, oy: float, scale: float = 1.0,
 ) -> bool:
     """Circle vs polygon with tile offset applied inline — no allocation."""
-    if _point_in_polygon_offset(cx, cy, vertices, ox, oy):
+    if _point_in_polygon_offset(cx, cy, vertices, ox, oy, scale):
         return True
     n = len(vertices)
     for i in range(n):
-        x1, y1 = vertices[i][0] + ox, vertices[i][1] + oy
-        x2, y2 = vertices[(i + 1) % n][0] + ox, vertices[(i + 1) % n][1] + oy
+        x1, y1 = vertices[i][0] * scale + ox, vertices[i][1] * scale + oy
+        x2, y2 = vertices[(i + 1) % n][0] * scale + ox, vertices[(i + 1) % n][1] * scale + oy
         dx = x2 - x1
         dy = y2 - y1
         fx = cx - x1
@@ -246,7 +246,7 @@ def check_sprite_polygon_collision(
 
 
 def _check_sprite_polygon_offset(
-    sprite: ICollidableSprite, polygon: CollisionPolygon, ox: float, oy: float
+    sprite: ICollidableSprite, polygon: CollisionPolygon, ox: float, oy: float, scale: float = 1.0
 ) -> bool:
     """
     Check if sprite collides with a tile-local polygon at world offset (ox, oy).
@@ -256,17 +256,17 @@ def _check_sprite_polygon_offset(
     if isinstance(shape, RectangleShape):
         left = sprite.x + shape.offset[0]
         top  = sprite.y + shape.offset[1]
-        return _rect_polygon_collision_offset(left, top, shape.width, shape.height, polygon.vertices, ox, oy)
+        return _rect_polygon_collision_offset(left, top, shape.width, shape.height, polygon.vertices, ox, oy, scale)
     elif isinstance(shape, CircleShape):
         cx = sprite.x + shape.offset[0]
         cy = sprite.y + shape.offset[1]
-        return _circle_polygon_collision_offset(cx, cy, shape.radius, polygon.vertices, ox, oy)
+        return _circle_polygon_collision_offset(cx, cy, shape.radius, polygon.vertices, ox, oy, scale)
     elif isinstance(shape, CapsuleShape):
         left = sprite.x + shape.offset[0] - shape.radius
         top  = sprite.y + shape.offset[1]
         w    = shape.radius * 2
         h    = shape.height + shape.radius * 2
-        return _rect_polygon_collision_offset(left, top, w, h, polygon.vertices, ox, oy)
+        return _rect_polygon_collision_offset(left, top, w, h, polygon.vertices, ox, oy, scale)
     return False
 
 
@@ -304,6 +304,7 @@ class CollisionRunner:
         self,
         tile_size: Tuple[int, int] = (32, 32),
         mode: MovementMode = MovementMode.SLIDE,
+        render_scale: float = 1.0,
     ):
         """
         Initialize collision runner.
@@ -314,9 +315,15 @@ class CollisionRunner:
         Args:
             tile_size: Size of tiles in pixels (width, height)
             mode: Movement mode (slide, platformer, rpg)
+            render_scale: Visual scale factor for tile rendering (default 1.0)
         """
         self.tile_size = tile_size
         self.mode = mode
+        if render_scale <= 0:
+            raise ValueError(f"render_scale must be positive, got {render_scale}")
+        self.render_scale = render_scale
+        self._eff_tw = int(tile_size[0] * render_scale)
+        self._eff_th = int(tile_size[1] * render_scale)
 
         self.gravity = 800.0
         self.max_fall_speed = 600.0
@@ -334,8 +341,8 @@ class CollisionRunner:
 
     def get_tile_at(self, world_x: float, world_y: float) -> Tuple[int, int]:
         """Convert world position to tile coordinates"""
-        tile_x = int(world_x // self.tile_size[0])
-        tile_y = int(world_y // self.tile_size[1])
+        tile_x = int(world_x // self._eff_tw)
+        tile_y = int(world_y // self._eff_th)
         return (tile_x, tile_y)
 
     def get_tile_shapes(
@@ -352,10 +359,10 @@ class CollisionRunner:
         if tile_id is None or not tileset_collision.has_collision(tile_id):
             return []
 
-        tile_world_x = tile_x * self.tile_size[0]
-        tile_world_y = tile_y * self.tile_size[1]
+        tile_world_x = tile_x * self._eff_tw
+        tile_world_y = tile_y * self._eff_th
 
-        return tileset_collision.get_world_shapes(tile_id, tile_world_x, tile_world_y)
+        return tileset_collision.get_world_shapes(tile_id, tile_world_x, tile_world_y, self.render_scale)
 
     def get_nearby_tile_shapes(
         self,
@@ -372,7 +379,7 @@ class CollisionRunner:
         this allocation entirely.
         """
         left, top, right, bottom = get_shape_bounds(sprite)
-        tw, th = self.tile_size
+        tw, th = self._eff_tw, self._eff_th
 
         min_tile_x = int(left  // tw) - margin
         max_tile_x = int(right // tw) + margin
@@ -392,7 +399,7 @@ class CollisionRunner:
                 tile_world_y = tile_y * th
                 for poly in tile_data.shapes:
                     if poly.is_valid():
-                        shapes.append(poly.transform(tile_world_x, tile_world_y))
+                        shapes.append(poly.transform(tile_world_x, tile_world_y, self.render_scale))
         return shapes
 
     def _collides_at(
@@ -409,7 +416,7 @@ class CollisionRunner:
         inline, exits immediately on first hit.
         """
         left, top, right, bottom = get_shape_bounds(sprite)
-        tw, th = self.tile_size
+        tw, th = self._eff_tw, self._eff_th
 
         min_tile_x = int(left  // tw) - margin
         max_tile_x = int(right // tw) + margin
@@ -427,7 +434,7 @@ class CollisionRunner:
                 ox = tile_x * tw
                 oy = tile_y * th
                 for poly in tile_data.shapes:
-                    if poly.is_valid() and _check_sprite_polygon_offset(sprite, poly, ox, oy):
+                    if poly.is_valid() and _check_sprite_polygon_offset(sprite, poly, ox, oy, self.render_scale):
                         return True
         return False
 
@@ -443,7 +450,7 @@ class CollisionRunner:
         Used by slope_slide to get the normal without allocating a full list.
         """
         left, top, right, bottom = get_shape_bounds(sprite)
-        tw, th = self.tile_size
+        tw, th = self._eff_tw, self._eff_th
 
         min_tile_x = int(left  // tw) - margin
         max_tile_x = int(right // tw) + margin
@@ -461,7 +468,7 @@ class CollisionRunner:
                 ox = tile_x * tw
                 oy = tile_y * th
                 for poly in tile_data.shapes:
-                    if poly.is_valid() and _check_sprite_polygon_offset(sprite, poly, ox, oy):
+                    if poly.is_valid() and _check_sprite_polygon_offset(sprite, poly, ox, oy, self.render_scale):
                         return (poly, ox, oy)
         return None
 
@@ -528,7 +535,7 @@ class CollisionRunner:
 
                 poly, ox, oy = hit
                 normal = self._get_collision_normal_from_motion(
-                    sprite, poly, ox, oy, motion_x, motion_y
+                    sprite, poly, ox, oy, motion_x, motion_y, self.render_scale
                 )
                 if normal:
                     dot = motion_x * normal[0] + motion_y * normal[1]
@@ -587,6 +594,7 @@ class CollisionRunner:
         oy: float,
         motion_x: float,
         motion_y: float,
+        scale: float = 1.0,
     ) -> Optional[Tuple[float, float]]:
         """
         Calculate the collision normal for a tile-local polygon at offset (ox, oy).
@@ -601,8 +609,8 @@ class CollisionRunner:
         poly_cx = 0.0
         poly_cy = 0.0
         for vx, vy in vertices:
-            poly_cx += vx
-            poly_cy += vy
+            poly_cx += vx * scale
+            poly_cy += vy * scale
         poly_cx = ox + poly_cx / n
         poly_cy = oy + poly_cy / n
 
@@ -610,8 +618,8 @@ class CollisionRunner:
         best_alignment = -1.0
 
         for i in range(n):
-            v1x, v1y = vertices[i][0] + ox,           vertices[i][1] + oy
-            v2x, v2y = vertices[(i + 1) % n][0] + ox, vertices[(i + 1) % n][1] + oy
+            v1x, v1y = vertices[i][0] * scale + ox,           vertices[i][1] * scale + oy
+            v2x, v2y = vertices[(i + 1) % n][0] * scale + ox, vertices[(i + 1) % n][1] * scale + oy
 
             edge_x = v2x - v1x
             edge_y = v2y - v1y
@@ -699,7 +707,7 @@ class CollisionRunner:
         collided_y = False
 
         left, top, right, bottom = get_shape_bounds(sprite)
-        tw, th = self.tile_size
+        tw, th = self._eff_tw, self._eff_th
         min_tile_x = int(left  // tw) - 1
         max_tile_x = int(right // tw) + 1
         min_tile_y = int(top   // th) - 1
@@ -718,11 +726,11 @@ class CollisionRunner:
                 for poly in tile_data.shapes:
                     if not poly.is_valid():
                         continue
-                    if not _check_sprite_polygon_offset(sprite, poly, ox, oy):
+                    if not _check_sprite_polygon_offset(sprite, poly, ox, oy, self.render_scale):
                         continue
                     if poly.one_way and sprite.vy > 0:
                         # one-way: only block if sprite was above the platform top
-                        min_vy = min(v[1] for v in poly.vertices) + oy
+                        min_vy = min(v[1] for v in poly.vertices) * self.render_scale + oy
                         if old_y + (bottom - top) <= min_vy:
                             collided_y = True
                             break
@@ -855,6 +863,7 @@ class CollisionRunner:
         game_type: str,
         tile_size: Tuple[int, int] = (32, 32),
         strict: bool = False,
+        render_scale: float = 1.0,
     ) -> "CollisionRunner":
         """
         Create a collision runner with preset configuration for a specific game type.
@@ -910,7 +919,7 @@ class CollisionRunner:
         game_type = game_type.lower()
 
         if game_type == "platformer":
-            runner = cls(tile_size, mode=MovementMode.PLATFORMER)
+            runner = cls(tile_size, mode=MovementMode.PLATFORMER, render_scale=render_scale)
             runner.gravity = 800.0
             runner.max_fall_speed = 600.0
             runner.jump_strength = -400.0
@@ -919,7 +928,7 @@ class CollisionRunner:
             runner._strict = strict
 
         elif game_type == "topdown":
-            runner = cls(tile_size, mode=MovementMode.SLIDE)
+            runner = cls(tile_size, mode=MovementMode.SLIDE, render_scale=render_scale)
             runner.gravity = 0.0
             runner.max_fall_speed = 0.0
             runner.jump_strength = 0.0
@@ -928,7 +937,7 @@ class CollisionRunner:
             runner._strict = strict
 
         elif game_type == "rpg":
-            runner = cls(tile_size, mode=MovementMode.RPG)
+            runner = cls(tile_size, mode=MovementMode.RPG, render_scale=render_scale)
             runner.gravity = 0.0
             runner.max_fall_speed = 0.0
             runner.jump_strength = 0.0

{tilemap_parser-3.0.0 → tilemap_parser-3.1.1}/src/tilemap_parser.egg-info/PKG-INFO

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

@@ -23,5 +23,7 @@ src/tilemap_parser/utils/__init__.py
 src/tilemap_parser/utils/geometry.py
 tests/test_collision.py
 tests/test_geometry.py
+tests/test_map_loader.py
 tests/test_object_collision.py
+tests/test_render_scale.py
 tests/test_tile_collision.py

tilemap_parser-3.1.1/tests/test_map_loader.py

@@ -0,0 +1,122 @@
+import json
+import os
+import tempfile
+from pathlib import Path
+
+import pygame
+import pytest
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from tilemap_parser.runtime.map_loader import TilemapData, _resolve_resource_path
+
+
+MINIMAL_MAP_META = {
+    "tile_size": "16;16",
+    "map_size": "10;10",
+    "version": "1.1",
+}
+
+
+def _make_minimal_png(path: Path, size: tuple[int, int] = (16, 16)) -> None:
+    surf = pygame.Surface(size)
+    surf.fill((255, 0, 255))
+    pygame.image.save(surf, str(path))
+
+
+def _make_map_json(tileset_path: str, data_dir: Path) -> Path:
+    payload = {
+        "meta": {**MINIMAL_MAP_META},
+        "resources": {"tilesets": [{"path": tileset_path, "type": "tile"}]},
+        "project_state": {"rules": [], "groups": []},
+        "data": {"ongrid": {}},
+    }
+    map_path = data_dir / "test_map.json"
+    with open(map_path, "w") as f:
+        json.dump(payload, f, indent=2)
+    return map_path
+
+
+@pytest.fixture(autouse=True)
+def pygame_init():
+    pygame.display.init()
+    pygame.display.set_mode((1, 1))
+    yield
+    pygame.quit()
+
+
+@pytest.fixture
+def tmp_project():
+    with tempfile.TemporaryDirectory() as tmp:
+        tmp = Path(tmp)
+        data_dir = tmp / "data"
+        assets_dir = tmp / "assets"
+        data_dir.mkdir()
+        assets_dir.mkdir()
+        yield tmp, data_dir, assets_dir
+
+
+@pytest.fixture
+def map_data(tmp_project):
+    tmp, data_dir, assets_dir = tmp_project
+    png = assets_dir / "tileset.png"
+    _make_minimal_png(png)
+    return tmp, data_dir, assets_dir, png
+
+
+class TestResolveResourcePath:
+    def test_relative_goes_up_to_assets(self, map_data):
+        tmp, data_dir, assets_dir, png = map_data
+        result = _resolve_resource_path("../assets/tileset.png", data_dir, None)
+        assert result == png.resolve()
+
+    def test_relative_within_data_fails(self, map_data):
+        tmp, data_dir, assets_dir, png = map_data
+        result = _resolve_resource_path("assets/tileset.png", data_dir, None)
+        assert not result.is_file()
+
+    def test_extra_search_base_fallback(self, map_data):
+        tmp, data_dir, assets_dir, png = map_data
+        result = _resolve_resource_path("assets/tileset.png", data_dir, extra_search_base=tmp)
+        assert result == png.resolve()
+
+    def test_absolute_path(self, tmp_project):
+        tmp, data_dir, assets_dir = tmp_project
+        png = tmp / "tileset.png"
+        _make_minimal_png(png)
+        result = _resolve_resource_path(str(png), tmp, None)
+        assert result == png
+        assert result.resolve() == png.resolve()
+
+
+class TestTilemapDataLoad:
+    def test_load_with_valid_map_relative_path(self, map_data):
+        tmp, data_dir, assets_dir, png = map_data
+        map_path = _make_map_json("../assets/tileset.png", data_dir)
+
+        td = TilemapData.load(map_path)
+
+        assert len(td.resolved_paths) == 1
+        assert td.resolved_paths[0] == png.resolve()
+        assert td.surfaces[0] is not None
+        assert len(td.warnings) == 0
+
+    def test_load_with_invalid_path_generates_warning(self, map_data):
+        tmp, data_dir, assets_dir, png = map_data
+        map_path = _make_map_json("assets/tileset.png", data_dir)
+
+        td = TilemapData.load(map_path)
+
+        assert len(td.warnings) >= 1
+        assert "missing" in td.warnings[0].lower()
+        assert td.surfaces[0] is None
+
+    def test_load_with_extra_search_base(self, map_data):
+        tmp, data_dir, assets_dir, png = map_data
+        map_path = _make_map_json("assets/tileset.png", data_dir)
+
+        td = TilemapData.load(map_path, extra_search_base=tmp)
+
+        assert td.resolved_paths[0] == png.resolve()
+        assert td.surfaces[0] is not None

{tilemap_parser-3.0.0 → tilemap_parser-3.1.1}/tests/test_object_collision.py

@@ -338,6 +338,73 @@ class TestCollisionHitHelpers:
         with pytest.raises(ValueError, match="not part"):
             hit.other(c)
 
+    # ------------------------------------------------------------------
+    # slide_velocity
+    # ------------------------------------------------------------------
+    def test_slide_head_on(self):
+        """Directly into surface → zero tangential motion."""
+        hit = CollisionHit(
+            object_a=None, object_b=None,
+            normal=(1.0, 0.0), depth=5.0,
+        )
+        sx, sy = hit.slide_velocity(10.0, 0.0)
+        assert sx == 0.0
+        assert sy == 0.0
+
+    def test_slide_angled(self):
+        """Diagonal into surface → only perpendicular component removed."""
+        hit = CollisionHit(
+            object_a=None, object_b=None,
+            normal=(1.0, 0.0), depth=5.0,
+        )
+        sx, sy = hit.slide_velocity(10.0, 5.0)
+        assert sx == 0.0  # x component fully removed
+        assert sy == 5.0  # y component preserved (tangential)
+
+    def test_slide_parallel(self):
+        """Velocity along the surface → unchanged."""
+        hit = CollisionHit(
+            object_a=None, object_b=None,
+            normal=(0.0, 1.0), depth=5.0,
+        )
+        sx, sy = hit.slide_velocity(10.0, 0.0)
+        assert sx == 10.0
+        assert sy == 0.0
+
+    def test_slide_away(self):
+        """Velocity pointing away from surface → unchanged."""
+        hit = CollisionHit(
+            object_a=None, object_b=None,
+            normal=(1.0, 0.0), depth=5.0,
+        )
+        sx, sy = hit.slide_velocity(-10.0, 0.0)
+        assert sx == -10.0
+        assert sy == 0.0
+
+    def test_slide_zero(self):
+        """Zero velocity → zero."""
+        hit = CollisionHit(
+            object_a=None, object_b=None,
+            normal=(1.0, 0.0), depth=5.0,
+        )
+        sx, sy = hit.slide_velocity(0.0, 0.0)
+        assert sx == 0.0
+        assert sy == 0.0
+
+    def test_slide_diagonal_normal(self):
+        """Normal at 45°, velocity into surface → slide along surface."""
+        import math
+        n = (1.0 / math.sqrt(2), 1.0 / math.sqrt(2))
+        hit = CollisionHit(
+            object_a=None, object_b=None,
+            normal=n, depth=5.0,
+        )
+        sx, sy = hit.slide_velocity(1.0, 0.0)
+        # Dot = 1/sqrt(2) ≈ 0.707
+        # slide = (1, 0) - (0.707, 0.707) * 0.707 = (1 - 0.5, -0.5)
+        assert sx == pytest.approx(0.5)
+        assert sy == pytest.approx(-0.5)
+
 
 # ---------------------------------------------------------------------------
 # Capsule collision

tilemap_parser-3.1.1/tests/test_render_scale.py

@@ -0,0 +1,424 @@
+"""
+Tests for render_scale support in the parser layer.
+
+Covers:
+- CollisionPolygon.transform with scale
+- TilesetCollision.get_world_shapes with scale
+- ParsedMeta.render_scale parsing
+- TilemapData.render_scale property
+- Inline offset functions with scale parameter
+- CollisionRunner with effective_tile_size
+"""
+
+import json
+import math
+import pytest
+from pathlib import Path
+from typing import Any, Dict, List, Tuple
+
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
+
+from tilemap_parser.parser.collision import CollisionPolygon, TilesetCollision, TileCollisionData, RectangleShape, CircleShape, CapsuleShape
+from tilemap_parser.parser.map_parse import ParsedMeta, parse_map_dict
+from tilemap_parser.runtime.tile_collision import (
+    CollisionRunner,
+    MovementMode,
+    _point_in_polygon_offset,
+    _rect_polygon_collision_offset,
+    _circle_polygon_collision_offset,
+    _check_sprite_polygon_offset,
+    get_shape_bounds,
+)
+
+
+# ---------------------------------------------------------------------------
+# Helpers — minimal sprite for collision tests
+# ---------------------------------------------------------------------------
+
+class DummySprite:
+    def __init__(self, x=0, y=0, shape=None, vx=0, vy=0, on_ground=False):
+        self.x = x
+        self.y = y
+        self.collision_shape = shape or RectangleShape(width=16, height=16)
+        self.vx = vx
+        self.vy = vy
+        self.on_ground = on_ground
+
+
+# ---------------------------------------------------------------------------
+# CollisionPolygon.transform
+# ---------------------------------------------------------------------------
+
+class TestCollisionPolygonTransformScale:
+    def test_no_scale_default(self):
+        poly = CollisionPolygon(vertices=[(0, 0), (16, 0), (16, 16), (0, 16)])
+        world = poly.transform(100, 200)
+        assert world.vertices == [
+            (100, 200), (116, 200), (116, 216), (100, 216)
+        ]
+
+    def test_scale_2x(self):
+        poly = CollisionPolygon(vertices=[(0, 0), (16, 0), (16, 16), (0, 16)])
+        world = poly.transform(100, 200, scale=2.0)
+        # tile_x/y already in world space; vertices get multiplied by scale
+        assert world.vertices == [
+            (100, 200), (132, 200), (132, 232), (100, 232)
+        ]
+
+    def test_scale_half(self):
+        poly = CollisionPolygon(vertices=[(10, 10), (20, 10), (20, 20)])
+        world = poly.transform(50, 50, scale=0.5)
+        # tile_x=50, tile_y=50; vertices: 10*0.5=5, 20*0.5=10
+        # (50+5, 50+5) = (55, 55)
+        # (50+10, 50+5) = (60, 55)
+        # (50+10, 50+10) = (60, 60)
+        assert world.vertices == [
+            (55.0, 55.0), (60.0, 55.0), (60.0, 60.0)
+        ]
+
+    def test_scale_non_uniform_tile_offset(self):
+        poly = CollisionPolygon(vertices=[(4, 8)])
+        world = poly.transform(32, 64, scale=2.0)
+        # 32 + 4*2 = 40, 64 + 8*2 = 80
+        assert world.vertices == [(40, 80)]
+
+    def test_scale_one_way_preserved(self):
+        poly = CollisionPolygon(vertices=[(0, 0), (32, 0), (32, 32)], one_way=True)
+        world = poly.transform(0, 0, scale=3.0)
+        assert world.one_way is True
+
+
+# ---------------------------------------------------------------------------
+# TilesetCollision.get_world_shapes
+# ---------------------------------------------------------------------------
+
+class TestGetWorldShapesScale:
+    @pytest.fixture
+    def ts_coll(self):
+        return TilesetCollision(
+            tileset_name="test",
+            tile_size=(32, 32),
+            tiles={
+                0: TileCollisionData(
+                    tile_id=0,
+                    shapes=[
+                        CollisionPolygon(vertices=[(0, 0), (32, 0), (32, 32), (0, 32)]),
+                    ],
+                ),
+            },
+        )
+
+    def test_default_scale(self, ts_coll):
+        shapes = ts_coll.get_world_shapes(0, 64, 128)
+        assert shapes[0].vertices == [(64, 128), (96, 128), (96, 160), (64, 160)]
+
+    def test_custom_scale(self, ts_coll):
+        shapes = ts_coll.get_world_shapes(0, 64, 128, scale=2.0)
+        assert shapes[0].vertices == [(64, 128), (128, 128), (128, 192), (64, 192)]
+
+    def test_missing_tile_returns_empty(self, ts_coll):
+        assert ts_coll.get_world_shapes(999, 0, 0, scale=2.0) == []
+
+
+# ---------------------------------------------------------------------------
+# ParsedMeta.render_scale
+# ---------------------------------------------------------------------------
+
+class TestParsedMetaRenderScale:
+    def test_default_render_scale(self):
+        meta = ParsedMeta(
+            tile_size=(16, 16),
+            map_size=(10, 10),
+            initial_map_size=(10, 10),
+            zoom_level=1.0,
+            scroll=(0, 0),
+            version="1.1",
+        )
+        assert meta.render_scale == 1.0
+
+    def test_custom_render_scale(self):
+        meta = ParsedMeta(
+            tile_size=(16, 16),
+            map_size=(10, 10),
+            initial_map_size=(10, 10),
+            zoom_level=1.0,
+            scroll=(0, 0),
+            version="1.1",
+            render_scale=3.0,
+        )
+        assert meta.render_scale == 3.0
+
+    def test_parsed_from_map_dict(self):
+        """render_scale is read from meta dict by parse_map_dict"""
+        root = {
+            "meta": {
+                "tile_size": "16,16",
+                "map_size": "10,10",
+                "zoom_level": 1.0,
+                "scroll": "0,0",
+                "version": "1.1",
+                "render_scale": 2.5,
+            },
+            "data": {"layers": []},
+            "project_state": {"rules": [], "groups": []},
+        }
+        parsed = parse_map_dict(root)
+        assert parsed.meta.render_scale == 2.5
+
+    def test_parsed_defaults_to_1_0_when_missing(self):
+        root = {
+            "meta": {
+                "tile_size": "16,16",
+                "map_size": "10,10",
+                "zoom_level": 1.0,
+                "scroll": "0,0",
+                "version": "1.1",
+            },
+            "data": {"layers": []},
+            "project_state": {"rules": [], "groups": []},
+        }
+        parsed = parse_map_dict(root)
+        assert parsed.meta.render_scale == 1.0
+
+    def test_parsed_rejects_non_numeric(self):
+        root = {
+            "meta": {
+                "tile_size": "16,16",
+                "map_size": "10,10",
+                "zoom_level": 1.0,
+                "scroll": "0,0",
+                "version": "1.1",
+                "render_scale": "not-a-number",
+            },
+            "data": {"layers": []},
+            "project_state": {"rules": [], "groups": []},
+        }
+        with pytest.raises(Exception):
+            parse_map_dict(root)
+
+
+# ---------------------------------------------------------------------------
+# Inline offset functions with scale parameter
+# ---------------------------------------------------------------------------
+
+class TestInlineOffsetScale:
+    """_point_in_polygon_offset, _rect_polygon_collision_offset,
+    _circle_polygon_collision_offset, _check_sprite_polygon_offset with scale."""
+
+    def test_point_offset_scale(self):
+        """_point_in_polygon_offset scales vertices before offset"""
+        verts = [(0, 0), (10, 0), (10, 10), (0, 10)]
+        # ox=100, oy=200, scale=2 → world vertices: [(100,200), (120,200), (120,220), (100,220)]
+        # point (90, 190) is outside (below and left)
+        assert _point_in_polygon_offset(90, 190, verts, 100, 200, scale=2.0) is False
+        # center of scaled polygon: (10,10)*2 + (100,200) = (120, 220)
+        assert _point_in_polygon_offset(120, 220, verts, 100, 200, scale=2.0) is True
+
+    def test_rect_offset_scale(self):
+        """_rect_polygon_collision_offset scales vertices"""
+        verts = [(0, 0), (10, 0), (10, 10), (0, 10)]
+        # scale=2, ox=0, oy=0 → polygon covers (0,0) to (20,20)
+        # rect at (5, 5, 10, 10) should collide
+        assert _rect_polygon_collision_offset(5, 5, 10, 10, verts, 0, 0, scale=2.0) is True
+        # rect at (25, 25, 5, 5) should not
+        assert _rect_polygon_collision_offset(25, 25, 5, 5, verts, 0, 0, scale=2.0) is False
+
+    def test_circle_offset_scale(self):
+        """_circle_polygon_collision_offset scales vertices"""
+        verts = [(0, 0), (10, 0), (10, 10), (0, 10)]
+        # scale=2, ox=0, oy=0 → polygon covers (0,0) to (20,20)
+        # circle at center (10, 10) radius 5 should collide
+        assert _circle_polygon_collision_offset(10, 10, 5, verts, 0, 0, scale=2.0) is True
+        # far away should not
+        assert _circle_polygon_collision_offset(100, 100, 5, verts, 0, 0, scale=2.0) is False
+
+    def test_rect_collision_scale_defaults_to_1(self):
+        """scale=1.0 should give same result as no scale"""
+        verts = [(0, 0), (10, 0), (10, 10), (0, 10)]
+        assert _rect_polygon_collision_offset(2, 2, 5, 5, verts, 5, 5, scale=1.0) == \
+               _rect_polygon_collision_offset(2, 2, 5, 5, verts, 5, 5)
+
+    def test_check_sprite_polygon_offset_scale(self):
+        """_check_sprite_polygon_offset passes scale through"""
+        verts = [(0, 0), (16, 0), (16, 16), (0, 16)]
+        poly = CollisionPolygon(vertices=verts)
+        sprite = DummySprite(x=100, y=100, shape=RectangleShape(width=16, height=16))
+        # ox=0, oy=0, scale=2 → polygon covers (0,0) to (32,32)
+        # sprite at (100,100) out of range
+        assert _check_sprite_polygon_offset(sprite, poly, 0, 0, scale=2.0) is False
+        # sprite at (0,0) should intersect
+        sprite.x = 0
+        sprite.y = 0
+        assert _check_sprite_polygon_offset(sprite, poly, 0, 0, scale=2.0) is True
+
+
+# ---------------------------------------------------------------------------
+# CollisionRunner
+# ---------------------------------------------------------------------------
+
+class TestCollisionRunnerRenderScale:
+    def test_default_render_scale(self):
+        runner = CollisionRunner(tile_size=(32, 32))
+        assert runner.render_scale == 1.0
+        assert runner._eff_tw == 32
+        assert runner._eff_th == 32
+
+    def test_custom_scale_effective_size(self):
+        runner = CollisionRunner(tile_size=(32, 32), render_scale=2.0)
+        assert runner.render_scale == 2.0
+        assert runner._eff_tw == 64
+        assert runner._eff_th == 64
+
+    def test_non_integer_scale(self):
+        runner = CollisionRunner(tile_size=(16, 16), render_scale=1.5)
+        assert runner._eff_tw == 24  # int(16 * 1.5)
+        assert runner._eff_th == 24
+
+    def test_get_tile_at_with_scale(self):
+        runner = CollisionRunner(tile_size=(32, 32), render_scale=2.0)
+        # world pos at (63, 63) → tile 0 (since eff_tw=64)
+        assert runner.get_tile_at(63, 63) == (0, 0)
+        # world pos at (64, 64) → tile 1
+        assert runner.get_tile_at(64, 64) == (1, 1)
+
+    def test_get_tile_at_no_scale(self):
+        runner = CollisionRunner(tile_size=(32, 32))
+        # world pos at (31, 31) → tile 0
+        assert runner.get_tile_at(31, 31) == (0, 0)
+        # world pos at (32, 32) → tile 1
+        assert runner.get_tile_at(32, 32) == (1, 1)
+
+    def test_scale_affects_collision_query(self):
+        """With render_scale=2, the effective grid is 64x64, affecting which
+        tiles are checked for collision at a given world position."""
+        runner = CollisionRunner(tile_size=(32, 32), render_scale=2.0)
+        eff_tw = runner._eff_tw  # 64
+        # A tile_map with a single tile at (0,0)
+        tile_map = {(0, 0): 0}
+        ts_coll = TilesetCollision(
+            tileset_name="test",
+            tile_size=(32, 32),
+            tiles={
+                0: TileCollisionData(
+                    tile_id=0,
+                    shapes=[CollisionPolygon(vertices=[(0, 0), (32, 0), (32, 32), (0, 32)])],
+                ),
+            },
+        )
+
+        # sprite at (10, 10) with 16x16 rect shape should collide with tile (0, 0)
+        sprite = DummySprite(x=10, y=10, shape=RectangleShape(width=16, height=16))
+        # _collides_at internally checks tiles using eff_tw/eff_th and passes self.render_scale
+        assert runner._collides_at(sprite, ts_coll, tile_map) is True
+
+        # sprite far to the right at (128, 10) should NOT collide (tile (0,0) world is 0..64)
+        sprite2 = DummySprite(x=128, y=10, shape=RectangleShape(width=16, height=16))
+        # sprite at (128, 10) with 16 wide → bounds 128..144, tile_x = 128//64 = 2 → no tile at (2,0)
+        assert runner._collides_at(sprite2, ts_coll, tile_map) is False
+
+    def test_from_game_type_passes_scale(self):
+        runner = CollisionRunner.from_game_type("platformer", tile_size=(16, 16), render_scale=3.0)
+        assert runner.render_scale == 3.0
+        assert runner._eff_tw == 48
+        assert runner._eff_th == 48
+
+    def test_from_game_type_default_scale(self):
+        runner = CollisionRunner.from_game_type("topdown", tile_size=(16, 16))
+        assert runner.render_scale == 1.0
+        assert runner._eff_tw == 16
+        assert runner._eff_th == 16
+
+    def test_collides_at_inline_offset_pass_scale(self):
+        """Verify _collides_at passes scale down to _check_sprite_polygon_offset
+        by checking edge-case with scaled vertices."""
+        runner = CollisionRunner(tile_size=(8, 8), render_scale=2.0)
+        # eff_tw = 16, eff_th = 16
+        # A triangle polygon that only fills bottom-right corner of tile
+        verts = [(0, 0), (8, 0), (4, 8)]
+        ts_coll = TilesetCollision(
+            tileset_name="test",
+            tile_size=(8, 8),
+            tiles={0: TileCollisionData(tile_id=0, shapes=[CollisionPolygon(vertices=verts)])},
+        )
+        tile_map = {(0, 0): 0}
+        # sprite at (8, 12) with 4x4 rect
+        # With scale=2, vertices become (0,0)*2=0, (8,0)*2=16, (4,8)*2=8+16=24 in world:
+        # (16,0), (0,0), (8,16). ox=0, oy=0.
+        # Wait, ox = tile_x * eff_tw = 0*16 = 0
+        # Vertices are tile-local: [(0,0), (8,0), (4,8)]
+        # Scaled: [(0,0), (16,0), (8,16)]
+        # + offset (0,0) → world: [(0,0), (16,0), (8,16)]
+        # Sprite bounds: x=8, y=12, w=4, h=4 → (8..12, 12..16)
+        # Scaled triangle: [(0,0), (16,0), (8,16)] — at y=12 the triangle spans x=6..10,
+        # which overlaps the sprite rect (8..12, 12..16). So collision IS expected.
+        sprite = DummySprite(x=8, y=12, shape=RectangleShape(width=4, height=4))
+        assert runner._collides_at(sprite, ts_coll, tile_map) is True
+
+
+# ---------------------------------------------------------------------------
+# CollisionRunner.get_tile_shapes and get_nearby_tile_shapes
+# ---------------------------------------------------------------------------
+
+class TestRunnerTileShapeMethodsScale:
+    @pytest.fixture
+    def ts_coll(self):
+        return TilesetCollision(
+            tileset_name="test",
+            tile_size=(32, 32),
+            tiles={
+                0: TileCollisionData(
+                    tile_id=0,
+                    shapes=[CollisionPolygon(vertices=[(0, 0), (32, 0), (32, 32), (0, 32)])],
+                ),
+            },
+        )
+
+    def test_get_tile_shapes_with_scale(self, ts_coll):
+        runner = CollisionRunner(tile_size=(32, 32), render_scale=2.0)
+        tile_map = {(0, 0): 0, (1, 0): 0}
+        # world pos (10, 10) → tile (0, 0) → tile world = (0*64, 0*64) = (0,0)
+        # vertices scaled by 2.0: [(0,0), (64,0), (64,64), (0,64)]
+        # + offset (0,0) → same
+        shapes = runner.get_tile_shapes(ts_coll, tile_map, 10, 10)
+        assert len(shapes) == 1
+        assert shapes[0].vertices == [(0, 0), (64, 0), (64, 64), (0, 64)]
+
+    def test_get_nearby_tile_shapes_with_scale(self, ts_coll):
+        runner = CollisionRunner(tile_size=(32, 32), render_scale=2.0)
+        tile_map = {(0, 0): 0, (1, 0): 0}
+        sprite = DummySprite(x=10, y=10, shape=RectangleShape(width=16, height=16))
+        shapes = runner.get_nearby_tile_shapes(ts_coll, tile_map, sprite, margin=0)
+        assert len(shapes) == 1
+
+
+# ---------------------------------------------------------------------------
+# TilemapData.render_scale (integration with map_loader)
+# ---------------------------------------------------------------------------
+
+class TestTilemapDataRenderScale:
+    def test_render_scale_property_exists(self):
+        """Verify TilemapData has a render_scale property read from parsed meta"""
+        from tilemap_parser.runtime.map_loader import TilemapData
+
+        class MockParsedMap:
+            pass
+
+        meta = ParsedMeta(
+            tile_size=(16, 16),
+            map_size=(10, 10),
+            initial_map_size=(10, 10),
+            zoom_level=1.0,
+            scroll=(0, 0),
+            version="1.1",
+            render_scale=2.0,
+        )
+        mock = MockParsedMap()
+        mock.meta = meta
+        mock.layers = []
+        mock.tilesets = []
+        mock.project_state = None
+        mock.raw = {}
+        import pygame
+        data = TilemapData(mock, [], [], [])
+        assert data.render_scale == 2.0