tilemap-parser 5.0.3__tar.gz → 5.0.4__tar.gz

{tilemap_parser-5.0.3 → tilemap_parser-5.0.4}/PKG-INFO

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

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

{tilemap_parser-5.0.3 → tilemap_parser-5.0.4}/src/tilemap_parser/parser/collision.py

@@ -9,6 +9,7 @@ Provides parsing of collision data from JSON into data classes:
 
 from __future__ import annotations
 
+import math
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -34,6 +35,13 @@ class CollisionPolygon:
         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 scaled(self, scale: float) -> "CollisionPolygon":
+        """Return a copy with all vertices multiplied by *scale*."""
+        return CollisionPolygon(
+            vertices=[(vx * scale, vy * scale) for vx, vy in self.vertices],
+            one_way=self.one_way,
+        )
+
     def is_valid(self) -> bool:
         """Check if polygon has at least 3 vertices"""
         return len(self.vertices) >= 3
@@ -130,6 +138,14 @@ class RectangleShape:
         top = y + self.offset[1]
         return (left, top, left + self.width, top + self.height)
 
+    def scaled(self, scale: float) -> "RectangleShape":
+        """Return a copy with dimensions and offset multiplied by *scale*."""
+        return RectangleShape(
+            width=self.width * scale,
+            height=self.height * scale,
+            offset=(self.offset[0] * scale, self.offset[1] * scale),
+        )
+
 
 @dataclass
 class CircleShape:
@@ -142,6 +158,13 @@ class CircleShape:
         """Get center position in world space"""
         return (x + self.offset[0], y + self.offset[1])
 
+    def scaled(self, scale: float) -> "CircleShape":
+        """Return a copy with radius and offset multiplied by *scale*."""
+        return CircleShape(
+            radius=self.radius * scale,
+            offset=(self.offset[0] * scale, self.offset[1] * scale),
+        )
+
 
 @dataclass
 class CapsuleShape:
@@ -159,6 +182,14 @@ class CapsuleShape:
         """Get bottom circle center in world space"""
         return (x + self.offset[0], y + self.offset[1] + self.height)
 
+    def scaled(self, scale: float) -> "CapsuleShape":
+        """Return a copy with radius, height, and offset multiplied by *scale*."""
+        return CapsuleShape(
+            radius=self.radius * scale,
+            height=self.height * scale,
+            offset=(self.offset[0] * scale, self.offset[1] * scale),
+        )
+
 
 CharacterShapeType = Union[RectangleShape, CircleShape, CapsuleShape, CollisionPolygon]
 
@@ -173,6 +204,16 @@ class CharacterCollision:
     collision_layer: int = 1
     collision_mask: int = 0xFFFFFFFF
 
+    def scaled(self, scale: float) -> "CharacterCollision":
+        """Return a copy whose shape is scaled by *scale* (typically ``render_scale``)."""
+        return CharacterCollision(
+            name=self.name,
+            shape=self.shape.scaled(scale),
+            properties=dict(self.properties),
+            collision_layer=self.collision_layer,
+            collision_mask=self.collision_mask,
+        )
+
 
 @dataclass
 class ObjectCollisionRegionData:
@@ -255,19 +296,28 @@ def parse_tileset_collision(data: JsonDict) -> TilesetCollision:
         raise CollisionParseError(f"Invalid tileset collision data: {e}") from e
 
 
-def parse_character_collision(data: JsonDict) -> CharacterCollision:
+def parse_character_collision(data: JsonDict, render_scale: float = 1.0) -> CharacterCollision:
     """
     Parse character collision data from dictionary.
 
     Args:
         data: Dictionary loaded from .collision.json file
+        render_scale: Multiplier applied to shape dimensions and offsets
+            (no-op when 1.0).
 
     Returns:
         CharacterCollision object
 
     Raises:
-        CollisionParseError: If data format is invalid
+        CollisionParseError: If data format is invalid or render_scale is not
+            finite and greater than zero.
     """
+    if (
+        not isinstance(render_scale, (int, float))
+        or not math.isfinite(render_scale)
+        or render_scale <= 0
+    ):
+        raise CollisionParseError(f"render_scale must be finite and > 0, got {render_scale!r}")
     try:
         name = data["name"]
         shape_data = data["shape"]
@@ -312,7 +362,7 @@ def parse_character_collision(data: JsonDict) -> CharacterCollision:
             properties=properties,
             collision_layer=collision_layer,
             collision_mask=collision_mask,
-        )
+        ).scaled(render_scale)
     except (KeyError, ValueError, TypeError) as e:
         raise CollisionParseError(f"Invalid character collision data: {e}") from e
 

{tilemap_parser-5.0.3 → tilemap_parser-5.0.4}/src/tilemap_parser/parser/collision_loader.py

@@ -55,6 +55,7 @@ def load_tileset_collision(
 
 def load_character_collision(
     collision_path: Union[str, Path],
+    render_scale: float = 1.0,
 ) -> CharacterCollision | None:
     """
     Load character collision data from a collision JSON file.
@@ -64,6 +65,8 @@ def load_character_collision(
 
     Args:
         collision_path: Direct path to the .collision.json file.
+        render_scale: Multiplier applied to shape dimensions and offsets
+            (no-op when 1.0).
 
     Returns:
         CharacterCollision object, or None if the file does not exist.
@@ -79,7 +82,7 @@ def load_character_collision(
     try:
         with open(collision_path, "r", encoding="utf-8") as f:
             data = json.load(f)
-        return parse_character_collision(data)
+        return parse_character_collision(data, render_scale=render_scale)
     except (OSError, UnicodeDecodeError, json.JSONDecodeError) as e:
         raise CollisionParseError(f"Cannot load {collision_path}: {e}") from e
 

{tilemap_parser-5.0.3 → tilemap_parser-5.0.4}/src/tilemap_parser/runtime/animation_player.py

@@ -20,6 +20,9 @@ class SpriteAnimationSet:
     json_path: Optional[Path] = None
     grid_offset_x: int = 0
     grid_offset_y: int = 0
+    render_scale: float = 1.0
+    grid_columns: int = 0
+    grid_rows: int = 0
 
     @classmethod
     def load(
@@ -28,6 +31,7 @@ class SpriteAnimationSet:
         *,
         spritesheet_path: Optional[PathLike] = None,
         extra_search_base: Optional[Path] = None,
+        render_scale: float = 1.0,
     ) -> "SpriteAnimationSet":
         path = Path(json_path)
         library = parse_animation_file(path)
@@ -59,6 +63,29 @@ class SpriteAnimationSet:
         except pygame.error as e:
             raise AnimationParseError(f"Failed to load image {image_path}: {e}") from e
 
+        tw, th = library.tile_size
+        ox, oy = library.grid_offset
+        grid_columns = max(1, (surface.get_width() - ox) // tw)
+        grid_rows = max(1, (surface.get_height() - oy) // th)
+
+        if render_scale != 1.0:
+            if render_scale <= 0:
+                raise ValueError(f"render_scale must be > 0, got {render_scale}")
+            w, h = surface.get_size()
+            sw, sh = int(w * render_scale), int(h * render_scale)
+            stw, sth = int(tw * render_scale), int(th * render_scale)
+            if sw < 1 or sh < 1 or stw < 1 or sth < 1:
+                raise ValueError(f"render_scale {render_scale} produces zero-sized atlas cells")
+            if (
+                int(ox * render_scale) + grid_columns * stw > sw
+                or int(oy * render_scale) + grid_rows * sth > sh
+            ):
+                raise ValueError(
+                    f"render_scale {render_scale} cannot maintain atlas grid cell bounds"
+                )
+            surface = pygame.transform.scale(surface, (sw, sh))
+            library = _scaled_library(library, render_scale)
+
         return cls(
             library=library,
             surface=surface,
@@ -66,6 +93,9 @@ class SpriteAnimationSet:
             json_path=path,
             grid_offset_x=library.grid_offset[0],
             grid_offset_y=library.grid_offset[1],
+            render_scale=render_scale,
+            grid_columns=grid_columns,
+            grid_rows=grid_rows,
         )
 
     def get_content_bounds(self, clip_name: str) -> Optional[Rect]:
@@ -88,15 +118,10 @@ class SpriteAnimationSet:
 
     def get_image(self, variant_id: int, *, copy_surface: bool = True) -> Optional[Surface]:
         tw, th = self.library.tile_size
-        if tw <= 0 or th <= 0:
-            return None
-        available_w = self.surface.get_width() - self.grid_offset_x
-        available_h = self.surface.get_height() - self.grid_offset_y
-        if available_w < tw or available_h < th:
+        if tw <= 0 or th <= 0 or self.grid_columns <= 0 or self.grid_rows <= 0:
             return None
-        cols = max(1, available_w // tw)
-        col = variant_id % cols
-        row = variant_id // cols
+        col = variant_id % self.grid_columns
+        row = variant_id // self.grid_columns
         src = Rect(self.grid_offset_x + col * tw, self.grid_offset_y + row * th, tw, th)
         if not self.surface.get_rect().contains(src):
             return None
@@ -161,3 +186,19 @@ class AnimationPlayer:
         if variant not in self._frame_cache:
             self._frame_cache[variant] = self.animation_set.get_image(variant, copy_surface=True)
         return self._frame_cache[variant]
+
+
+def _scaled_library(library: AnimationLibrary, scale: float) -> AnimationLibrary:
+    """Return a copy of *library* whose grid geometry is scaled by *scale*.
+
+    Kept in lockstep with the scaled spritesheet surface so that
+    :meth:`SpriteAnimationSet.get_image` continues to address cells
+    correctly.
+    """
+    return AnimationLibrary(
+        animations=library.animations,
+        spritesheet_path=library.spritesheet_path,
+        tile_size=(int(library.tile_size[0] * scale), int(library.tile_size[1] * scale)),
+        grid_offset=(int(library.grid_offset[0] * scale), int(library.grid_offset[1] * scale)),
+        trim_transparent=library.trim_transparent,
+    )

{tilemap_parser-5.0.3 → tilemap_parser-5.0.4}/src/tilemap_parser/runtime/collision_cache.py

@@ -8,7 +8,7 @@ repeated file I/O during runtime.
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Dict, Optional, Union
+from typing import Dict, Optional, Tuple, Union
 
 from ..parser.collision import (
     CharacterCollision,
@@ -39,7 +39,7 @@ class CollisionCache:
 
     def __init__(self):
         self._tileset_cache: Dict[str, Optional[TilesetCollision]] = {}
-        self._character_cache: Dict[str, Optional[CharacterCollision]] = {}
+        self._character_cache: Dict[Tuple[str, float], Optional[CharacterCollision]] = {}
         self._object_cache: Dict[str, Optional[ObjectCollisionData]] = {}
 
     def get_tileset_collision(
@@ -58,17 +58,21 @@ class CollisionCache:
         return self._tileset_cache[key]
 
     def get_character_collision(
-        self, collision_path: Union[str, Path]
+        self, collision_path: Union[str, Path], render_scale: float = 1.0
     ) -> Optional[CharacterCollision]:
         """Get character collision data (cached).
 
         Args:
             collision_path: Direct path to the .collision.json file.
+            render_scale: Multiplier applied to shape dimensions and offsets.
+                Cached per (path, render_scale) pair.
         """
-        key = str(Path(collision_path).resolve())
+        key = (str(Path(collision_path).resolve()), render_scale)
 
         if key not in self._character_cache:
-            self._character_cache[key] = load_character_collision(collision_path)
+            self._character_cache[key] = load_character_collision(
+                collision_path, render_scale=render_scale
+            )
 
         return self._character_cache[key]
 
@@ -134,13 +138,15 @@ def get_cached_tileset_collision(
 
 def get_cached_character_collision(
     collision_path: Union[str, Path],
+    render_scale: float = 1.0,
 ) -> Optional[CharacterCollision]:
     """Get character collision using global cache.
 
     Args:
         collision_path: Direct path to the .collision.json file.
+        render_scale: Multiplier applied to shape dimensions and offsets.
     """
-    return _global_cache.get_character_collision(collision_path)
+    return _global_cache.get_character_collision(collision_path, render_scale=render_scale)
 
 
 def get_cached_object_collision(

{tilemap_parser-5.0.3 → tilemap_parser-5.0.4}/src/tilemap_parser/runtime/particles.py

@@ -177,6 +177,23 @@ def _make_heart_texture() -> Surface:
     return s
 
 
+def _make_line_texture() -> Surface:
+    # will be applied on next release not yet
+    """Vertical streak spanning the full canvas with a thin core.
+
+    Kept axis-aligned (not rotated): the renderer only rotates particles
+    when ``rotation_speed`` is non-zero, so a vertical line reads as a
+    falling streak for rain and stream effects.
+    """
+    s = Surface((PARTICLE_TEXTURE_SIZE, PARTICLE_TEXTURE_SIZE), pygame.SRCALPHA)
+    w = max(1, PARTICLE_TEXTURE_SIZE // 6)
+    x = (PARTICLE_TEXTURE_SIZE - w) // 2
+    pygame.draw.rect(s, (255, 255, 255, 255), Rect(x, 2, w, PARTICLE_TEXTURE_SIZE - 4))
+    pygame.draw.rect(s, (255, 255, 255, 140), Rect(x, 0, w, 2))
+    pygame.draw.rect(s, (255, 255, 255, 140), Rect(x, PARTICLE_TEXTURE_SIZE - 2, w, 2))
+    return s
+
+
 def _get_base_texture(shape: str) -> Surface:
     if shape not in _TEXTURE_CACHE:
         makers = {
@@ -188,6 +205,7 @@ def _get_base_texture(shape: str) -> Surface:
             "smoke": _make_smoke_texture,
             "fog": _make_fog_texture,
             "heart": _make_heart_texture,
+            "line": _make_line_texture,
         }
         maker = makers.get(shape, _make_circle_texture)
         _TEXTURE_CACHE[shape] = maker()

{tilemap_parser-5.0.3 → tilemap_parser-5.0.4}/src/tilemap_parser.egg-info/PKG-INFO

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

@@ -192,6 +192,60 @@ class TestParseCharacterCollision:
         result = parse_character_collision(data)
         assert result.properties == {}
 
+    def test_render_scale_rectangle(self):
+        result = parse_character_collision(CHARACTER_RECT_DATA, render_scale=2.0)
+        assert isinstance(result.shape, RectangleShape)
+        assert result.shape.width == 48.0
+        assert result.shape.height == 64.0
+        assert result.shape.offset == (8.0, 0.0)
+
+    def test_render_scale_circle(self):
+        result = parse_character_collision(CHARACTER_CIRCLE_DATA, render_scale=3.0)
+        assert isinstance(result.shape, CircleShape)
+        assert result.shape.radius == 48.0
+
+    def test_render_scale_capsule(self):
+        result = parse_character_collision(CHARACTER_CAPSULE_DATA, render_scale=2.0)
+        assert isinstance(result.shape, CapsuleShape)
+        assert result.shape.radius == 16.0
+        assert result.shape.height == 96.0
+
+    def test_render_scale_polygon(self):
+        data = {
+            "name": "poly",
+            "shape": {
+                "type": "polygon",
+                "vertices": [[0, 0], [10, 0], [10, 10], [0, 10]],
+            },
+            "properties": {},
+        }
+        result = parse_character_collision(data, render_scale=2.0)
+        assert isinstance(result.shape, CollisionPolygon)
+        assert result.shape.vertices == [(0.0, 0.0), (20.0, 0.0), (20.0, 20.0), (0.0, 20.0)]
+
+    def test_render_scale_default_is_one(self):
+        result = parse_character_collision(CHARACTER_RECT_DATA)
+        assert isinstance(result.shape, RectangleShape)
+        assert result.shape.width == 24.0
+
+    def test_render_scale_zero_rejected(self):
+        with pytest.raises(CollisionParseError, match="render_scale"):
+            parse_character_collision(CHARACTER_RECT_DATA, render_scale=0)
+
+    def test_render_scale_negative_rejected(self):
+        with pytest.raises(CollisionParseError, match="render_scale"):
+            parse_character_collision(CHARACTER_RECT_DATA, render_scale=-1)
+
+    def test_render_scale_nonfinite_rejected(self):
+        for bad in (float("nan"), float("inf"), float("-inf")):
+            with pytest.raises(CollisionParseError, match="render_scale"):
+                parse_character_collision(CHARACTER_RECT_DATA, render_scale=bad)
+
+    def test_render_scale_non_numeric_rejected(self):
+        for bad in (None, "2", "abc"):
+            with pytest.raises(CollisionParseError, match="render_scale"):
+                parse_character_collision(CHARACTER_RECT_DATA, render_scale=bad)
+
 
 # ===========================================================================
 # Shape helpers
@@ -232,6 +286,54 @@ class TestShapeHelpers:
         assert transformed.vertices[1] == (15.0, 7.0)
         assert transformed.vertices[2] == (15.0, 17.0)
 
+    def test_rectangle_scaled(self):
+        shape = RectangleShape(width=24.0, height=32.0, offset=(4.0, 0.0))
+        scaled = shape.scaled(2.0)
+        assert isinstance(scaled, RectangleShape)
+        assert scaled.width == 48.0
+        assert scaled.height == 64.0
+        assert scaled.offset == (8.0, 0.0)
+        assert shape.width == 24.0  # original untouched
+
+    def test_circle_scaled(self):
+        shape = CircleShape(radius=16.0, offset=(2.0, 3.0))
+        scaled = shape.scaled(3.0)
+        assert isinstance(scaled, CircleShape)
+        assert scaled.radius == 48.0
+        assert scaled.offset == (6.0, 9.0)
+
+    def test_capsule_scaled(self):
+        shape = CapsuleShape(radius=8.0, height=48.0, offset=(0.0, 2.0))
+        scaled = shape.scaled(1.5)
+        assert isinstance(scaled, CapsuleShape)
+        assert scaled.radius == 12.0
+        assert scaled.height == 72.0
+        assert scaled.offset == (0.0, 3.0)
+
+    def test_collision_polygon_scaled(self):
+        poly = CollisionPolygon(vertices=[(0.0, 0.0), (10.0, 0.0), (10.0, 10.0)], one_way=True)
+        scaled = poly.scaled(2.0)
+        assert isinstance(scaled, CollisionPolygon)
+        assert scaled.vertices == [(0.0, 0.0), (20.0, 0.0), (20.0, 20.0)]
+        assert scaled.one_way is True
+
+    def test_scaled_one_is_identity(self):
+        shape = RectangleShape(width=24.0, height=32.0, offset=(4.0, 0.0))
+        assert shape.scaled(1.0) == shape
+
+    def test_character_collision_scaled(self):
+        coll = parse_character_collision(CHARACTER_RECT_DATA)
+        scaled = coll.scaled(2.0)
+        assert scaled.name == coll.name
+        assert isinstance(scaled.shape, RectangleShape)
+        assert scaled.shape.width == 48.0
+        assert scaled.shape.height == 64.0
+        assert scaled.shape.offset == (8.0, 0.0)
+        assert scaled.collision_layer == coll.collision_layer
+        assert scaled.collision_mask == coll.collision_mask
+        assert scaled.properties == coll.properties
+        assert coll.shape.width == 24.0  # original untouched
+
 
 # ===========================================================================
 # load_tileset_collision — direct path API
@@ -308,6 +410,16 @@ class TestLoadCharacterCollision:
         result = load_character_collision(CHARACTER_COLLISION)
         assert isinstance(result.shape, RectangleShape)
 
+    def test_render_scale_scales_shape(self):
+        base = load_character_collision(CHARACTER_COLLISION)
+        scaled = load_character_collision(CHARACTER_COLLISION, render_scale=2.0)
+        assert base is not None and scaled is not None
+        assert isinstance(base.shape, RectangleShape)
+        assert isinstance(scaled.shape, RectangleShape)
+        assert scaled.shape.width == base.shape.width * 2.0
+        assert scaled.shape.height == base.shape.height * 2.0
+        assert scaled.shape.offset == (base.shape.offset[0] * 2.0, base.shape.offset[1] * 2.0)
+
     def test_non_json_file_raises(self, tmp_path):
         # Passing a non-JSON file (e.g. an image) raises CollisionParseError,
         # not silently returns None — the file exists so we try to parse it.
@@ -357,7 +469,7 @@ class TestCollisionCache:
 
     def test_preload_character(self):
         self.cache.preload_character(CHARACTER_COLLISION)
-        key = str(CHARACTER_COLLISION.resolve())
+        key = (str(CHARACTER_COLLISION.resolve()), 1.0)
         assert key in self.cache._character_cache
 
     def test_cache_key_is_resolved_path(self, tmp_path):
@@ -369,6 +481,14 @@ class TestCollisionCache:
         r2 = self.cache.get_tileset_collision(link)
         assert r1 is r2
 
+    def test_character_cache_separates_render_scales(self):
+        r1 = self.cache.get_character_collision(CHARACTER_COLLISION)
+        r2 = self.cache.get_character_collision(CHARACTER_COLLISION, render_scale=1.0)
+        r3 = self.cache.get_character_collision(CHARACTER_COLLISION, render_scale=2.0)
+        assert r1 is r2  # same scale -> same cached object
+        assert r1 is not r3  # different scale -> separate cache entry
+        assert r3.shape.width == r1.shape.width * 2.0
+
 
 # ===========================================================================
 # Global cache helpers

{tilemap_parser-5.0.3 → tilemap_parser-5.0.4}/tests/test_integration_animation.py

@@ -1,5 +1,8 @@
 from pathlib import Path
 
+import json
+
+import pygame
 import pytest
 
 from tilemap_parser import (
@@ -115,6 +118,128 @@ class TestSpriteAnimationSetLoad:
         bounds = anim_set.get_content_bounds("nonexistent")
         assert bounds is None
 
+    def test_load_with_render_scale(self):
+        anim_set = SpriteAnimationSet.load(PLAYER_ANIM_PATH, render_scale=2.0)
+        assert anim_set.render_scale == 2.0
+        assert anim_set.surface.get_width() == 2400
+        assert anim_set.surface.get_height() == 840
+        assert anim_set.library.tile_size == (300, 120)
+        assert anim_set.library.grid_offset == (0, 0)
+        assert anim_set.grid_offset_x == 0
+
+    def test_render_scale_one_matches_default(self):
+        default = SpriteAnimationSet.load(PLAYER_ANIM_PATH)
+        explicit = SpriteAnimationSet.load(PLAYER_ANIM_PATH, render_scale=1.0)
+        assert explicit.render_scale == 1.0
+        assert explicit.surface.get_size() == default.surface.get_size()
+        assert explicit.library.tile_size == default.library.tile_size
+
+    def test_get_image_scaled_by_render_scale(self):
+        anim_set = SpriteAnimationSet.load(PLAYER_ANIM_PATH, render_scale=2.0)
+        img = anim_set.get_image(0)
+        assert img is not None
+        assert img.get_width() == 300
+        assert img.get_height() == 120
+
+    def test_get_image_cell_lookup_still_valid_at_scale(self):
+        anim_set = SpriteAnimationSet.load(PLAYER_ANIM_PATH, render_scale=2.0)
+        img = anim_set.get_image(8)
+        assert img is not None
+        assert img.get_size() == (300, 120)
+
+    def test_get_content_bounds_scaled(self):
+        base = SpriteAnimationSet.load(PLAYER_ANIM_PATH)
+        scaled = SpriteAnimationSet.load(PLAYER_ANIM_PATH, render_scale=3.0)
+        base_bounds = base.get_content_bounds("idle")
+        scaled_bounds = scaled.get_content_bounds("idle")
+        assert base_bounds is not None and scaled_bounds is not None
+        assert scaled_bounds.width == base_bounds.width * 3
+        assert scaled_bounds.height == base_bounds.height * 3
+        assert scaled_bounds.x == base_bounds.x * 3
+        assert scaled_bounds.y == base_bounds.y * 3
+
+    def test_invalid_render_scale_raises(self):
+        with pytest.raises(ValueError):
+            SpriteAnimationSet.load(PLAYER_ANIM_PATH, render_scale=0)
+
+    def test_zero_sized_scaled_cells_rejected(self):
+        for bad in (0.01, 0.0005):
+            with pytest.raises(ValueError, match="zero-sized"):
+                SpriteAnimationSet.load(PLAYER_ANIM_PATH, render_scale=bad)
+
+    def test_animation_player_frames_scaled(self):
+        anim_set = SpriteAnimationSet.load(PLAYER_ANIM_PATH, render_scale=2.0)
+        player = AnimationPlayer(anim_set, "idle")
+        img = player.get_current_image()
+        assert img is not None
+        assert img.get_size() == (300, 120)
+
+
+def _write_offset_atlas(tmp_path: Path, cols: int, rows: int):
+    """Write a synthetic atlas with a nonzero grid offset and solid per-cell colors."""
+    tile = 8
+    ox, oy = 1, 1
+    w, h = ox + cols * tile, oy + rows * tile
+    sheet = pygame.Surface((w, h))
+    colors = {}
+    for row in range(rows):
+        for col in range(cols):
+            idx = row * cols + col
+            color = (
+                (20 + idx * 7) % 256,
+                (40 + idx * 13) % 256,
+                (60 + idx * 29) % 256,
+            )
+            colors[idx] = color
+            sheet.fill(color, (ox + col * tile, oy + row * tile, tile, tile))
+    sheet.fill((250, 250, 250), (0, 0, w, oy))
+    sheet.fill((250, 250, 250), (0, 0, ox, h))
+    png_path = tmp_path / "atlas.png"
+    pygame.image.save(sheet, str(png_path))
+    json_path = tmp_path / "atlas.animation.json"
+    json_path.write_text(
+        json.dumps(
+            {
+                "spritesheet_path": str(png_path),
+                "tile_size": [tile, tile],
+                "grid_offset": [ox, oy],
+                "trim_transparent": False,
+                "animations": {
+                    "test": {
+                        "name": "test",
+                        "frames": [{"variant_id": 0, "duration_ms": 100.0}],
+                        "loop": True,
+                    }
+                },
+            }
+        )
+    )
+    return colors
+
+
+class TestFractionalScaleWithOffset:
+    def test_downscale_0_6_returns_correct_cell(self, tmp_path):
+        colors = _write_offset_atlas(tmp_path, cols=5, rows=3)
+        anim_set = SpriteAnimationSet.load(
+            tmp_path / "atlas.animation.json", render_scale=0.6
+        )
+        for variant in (0, 5, 6):
+            img = anim_set.get_image(variant)
+            assert img is not None
+            center = img.get_at((img.get_width() // 2, img.get_height() // 2))[:3]
+            assert center == colors[variant]
+
+    def test_upscale_1_1_returns_correct_cell(self, tmp_path):
+        colors = _write_offset_atlas(tmp_path, cols=12, rows=3)
+        anim_set = SpriteAnimationSet.load(
+            tmp_path / "atlas.animation.json", render_scale=1.1
+        )
+        for variant in (0, 12, 13):
+            img = anim_set.get_image(variant)
+            assert img is not None
+            center = img.get_at((img.get_width() // 2, img.get_height() // 2))[:3]
+            assert center == colors[variant]
+
 
 class TestAnimationPlayerPlayback:
     def test_initial_state(self):