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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 5.0.2
+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
@@ -699,106 +699,50 @@ Dynamic: license-file
 
 # tilemap-parser
 
-Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime.
+Standalone parser/loader for [tilemap-editor](https://pypi.org/project/tilemap-editor/) JSON maps, sprite animations, and a collision detection runtime.
 
-## Features
+## Install
 
-- **Map parsing**: Load and query tilemaps, layers, objects, and autotile data from JSON
-- **Chunked tile rendering**: Efficient visibility culling and chunk-based rendering with `TileLayerRenderer`
-- **Camera system**: Centered/deadzone follow, lerp smoothing, screen-shake, and bounds clamping with `Camera`
-- **Animation**: Frame-based sprite animation with `AnimationPlayer`
-- **Particle system**: Configurable particle emitters with shapes, color transitions, alpha fades, gravity, and batch rendering with `ParticleSystem` + `SpriteBatchRenderer`
-- **Collision (tile-based)**: Polygon collision detection for tilemaps with slide, platformer, and RPG movement modes via `CollisionRunner`
-- **Collision (object-to-object)**: Spatial-grid mixed-shape collision detection (rect, circle, capsule, polygon) with layer filtering via `ObjectCollisionManager`
-- **Capsule support**: Full capsule collision against all shape types
-- **Hit helpers**: `CollisionHit.resolve()`, `involves()`, `other()` for ergonomic separation
+```bash
+pip install tilemap-parser
+```
 
-## Quick Start
+## Quick start
 
 ```python
-from tilemap_parser import load_map, TileLayerRenderer, Camera
+from tilemap_parser import load_map, TileLayerRenderer, Camera, ParticleField, FOG_PROFILE
 
-# Load map and set up renderer
 game_data = load_map("path/to/map.json")
 renderer = TileLayerRenderer(game_data)
 
-# Set up camera
 camera = Camera(800, 600, mode="centered")
 camera.follow(player)
-```
-
-```python
-from tilemap_parser import (
-    CollisionRunner, CollisionCache,
-    ObjectCollisionManager, CircleShape, RectangleShape,
-    ParticleSystem, ParticleSystemConfig
-)
-
-# Tile-based collision
-cache = CollisionCache()
-tileset = cache.get_tileset_collision("data/collision/tileset.collision.json")
-runner = CollisionRunner.from_game_type("topdown", tile_size=(32, 32))
-
-# Object-to-object collision
-manager = ObjectCollisionManager()
-manager.add_object(player)
-for hit in manager.check_all_collisions():
-    hit.resolve()  # separate both objects
 
-# Particle system
-particle_config = ParticleSystemConfig(
-    particle_shape="circle",
-    spawn_rate=10.0,
-    max_particles=100,
-    lifetime_min=0.5,
-    lifetime_max=2.0,
-    speed_min=50,
-    speed_max=100,
-    direction=270,
-    spread=45,
-    start_color_r=255, start_color_g=200, start_color_b=100, start_color_a=255,
-    end_color_r=255, end_color_g=100, end_color_b=50, end_color_a=0,
-    alpha_fade="fade_out",
-    gravity_x=0,
-    gravity_y=50,
+# Persistent fog: fill once, wrap forever — no particle churn
+mist = ParticleField(
+    area=(0, 0, 800, 600),
+    profile=FOG_PROFILE,   # plain data — copy and tweak for your own moods
+    color=(200, 50, 80),
+    global_alpha=0.5,
 )
-particles = ParticleSystem(particle_config)
 ```
 
-## Physics bodies
-
-A `PhysicsWorld` is a single space holding the tile layer plus solid `Body` objects (static walls, kinematic crates). Attach a `CollisionRunner` to the world once and every move method resolves tiles and bodies through it — no per-call tile arguments.
-
-> Full contract — object↔world↔`move_*`↔tiles↔rendering: see [docs/physics-world.md](docs/physics-world.md) and `examples/physics-crate/main.py`.
-
-```python
-from tilemap_parser import (
-    Body, PhysicsWorld, CollisionRunner, RectangleShape,
-    TilemapData, TilesetCollision, CollisionCache,
-)
-
-cache = CollisionCache()
-tileset = cache.get_tileset_collision("data/collision/tileset.collision.json")
-world = PhysicsWorld.from_map(game_data, tileset)   # adopts tile_size / render_scale
-
-crate = Body(RectangleShape(width=16, height=16), x=320, y=480, mode="kinematic")
-world.add_body(crate)
-
-runner = CollisionRunner.from_world(world)          # or runner.attach(world)
-```
+## Features
 
-Pushable crates are just kinematic bodies moved with an explicit velocity (gravity is skipped when `velocity=` is given):
+- **Map parsing** — tilemaps, layers, objects, and autotile data from JSON
+- **Collision** — tile-based (`CollisionRunner`) and object-to-object (`ObjectCollisionManager`) with rect, circle, capsule, and polygon shapes
+- **Physics** — `PhysicsWorld` with static/kinematic `Body` solids and one-way platforms
+- **Particles** — wrapped continuous fields (`ParticleField`, `FOG_PROFILE`), burst emitters, alpha fades, and batch rendering (`SpriteBatchRenderer`)
+- **Pathfinding** — A* `Pathfinder` over eroded `NavGrid`s
+- **Animation** — frame-based `AnimationPlayer`, plus a `Camera` with centered/deadzone follow
+- **Rendering** — chunked `TileLayerRenderer` and `LayerRenderStats`
 
-```python
-# player pressed against the crate -> hand the player's vx over
-crate.vx = player.vx
-result = runner.move_grounded(crate, None, None, dt, velocity=(crate.vx, 0))
-if result.hit_wall_x:
-    crate.vx = 0  # crate stopped against a tile wall or another body
-```
+## Requirements
 
-`Body` accepts primitive shapes only (`RectangleShape`, `CircleShape`, `CapsuleShape`); use `MapObject` for polygon solids. Collision pairs honor both sides' `collision_layer` / `collision_mask`, and bodies are landing surfaces for platformer step-up (small crates are climbed, tall ones block like walls).
+- Python 3.10+
+- `pygame-ce>=2.5` (installed automatically)
 
-## Docs
+## Links
 
-Full documentation: [https://tilemap-parser.vercel.app/](https://tilemap-parser.vercel.app/)
+- **Documentation**: https://tilemap-parser.vercel.app/
+- **Repository**: https://github.com/FluffyBrudy/tilemap-parser

{tilemap_parser-5.0.2 → tilemap_parser-5.0.4}/README.md

@@ -100,6 +100,9 @@ if result.hit_wall_x:
 
 `Body` accepts primitive shapes only (`RectangleShape`, `CircleShape`, `CapsuleShape`); use `MapObject` for polygon solids. Collision pairs honor both sides' `collision_layer` / `collision_mask`, and bodies are landing surfaces for platformer step-up (small crates are climbed, tall ones block like walls).
 
-## Docs
+## Links
 
-Full documentation: [https://tilemap-parser.vercel.app/](https://tilemap-parser.vercel.app/)
+- **Docs**: [https://tilemap-parser.vercel.app/](https://tilemap-parser.vercel.app/)
+- **Docs (deepwiki)**: [https://deepwiki.com/FluffyBrudy/tilemap-parser](https://deepwiki.com/FluffyBrudy/tilemap-parser)
+- **Editor**: https://pypi.org/project/tilemap-editor/
+- **Repository**: https://github.com/FluffyBrudy/tilemap-parser

tilemap_parser-5.0.4/pypi-readme.md

@@ -0,0 +1,49 @@
+# tilemap-parser
+
+Standalone parser/loader for [tilemap-editor](https://pypi.org/project/tilemap-editor/) JSON maps, sprite animations, and a collision detection runtime.
+
+## Install
+
+```bash
+pip install tilemap-parser
+```
+
+## Quick start
+
+```python
+from tilemap_parser import load_map, TileLayerRenderer, Camera, ParticleField, FOG_PROFILE
+
+game_data = load_map("path/to/map.json")
+renderer = TileLayerRenderer(game_data)
+
+camera = Camera(800, 600, mode="centered")
+camera.follow(player)
+
+# Persistent fog: fill once, wrap forever — no particle churn
+mist = ParticleField(
+    area=(0, 0, 800, 600),
+    profile=FOG_PROFILE,   # plain data — copy and tweak for your own moods
+    color=(200, 50, 80),
+    global_alpha=0.5,
+)
+```
+
+## Features
+
+- **Map parsing** — tilemaps, layers, objects, and autotile data from JSON
+- **Collision** — tile-based (`CollisionRunner`) and object-to-object (`ObjectCollisionManager`) with rect, circle, capsule, and polygon shapes
+- **Physics** — `PhysicsWorld` with static/kinematic `Body` solids and one-way platforms
+- **Particles** — wrapped continuous fields (`ParticleField`, `FOG_PROFILE`), burst emitters, alpha fades, and batch rendering (`SpriteBatchRenderer`)
+- **Pathfinding** — A* `Pathfinder` over eroded `NavGrid`s
+- **Animation** — frame-based `AnimationPlayer`, plus a `Camera` with centered/deadzone follow
+- **Rendering** — chunked `TileLayerRenderer` and `LayerRenderStats`
+
+## Requirements
+
+- Python 3.10+
+- `pygame-ce>=2.5` (installed automatically)
+
+## Links
+
+- **Documentation**: https://tilemap-parser.vercel.app/
+- **Repository**: https://github.com/FluffyBrudy/tilemap-parser

{tilemap_parser-5.0.2 → tilemap_parser-5.0.4}/pyproject.toml

@@ -4,9 +4,9 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "5.0.2"
+version = "5.0.4"
 description = "Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime."
-readme = "README.md"
+readme = "pypi-readme.md"
 requires-python = ">=3.10"
 license = { file = "LICENSE" }
 authors = [{ name = "tilemap parser contributors" }]

{tilemap_parser-5.0.2 → tilemap_parser-5.0.4}/src/tilemap_parser/__init__.py

@@ -46,8 +46,13 @@ __all__ = [
     "TileLayerRenderer",
     "TilesetCollision",
     "TilemapData",
+    "FOG_PROFILE",
+    "FieldLayerSpec",
+    "FieldProfile",
     "Particle",
     "ParticleEmitter",
+    "ParticleField",
+    "ParticleFieldLayer",
     "ParticleRenderer",
     "ParticleSystem",
     "ParticleSystemConfig",

{tilemap_parser-5.0.2 → tilemap_parser-5.0.4}/src/tilemap_parser/parser/__init__.py

@@ -51,6 +51,10 @@ from .particle import (
     ALPHA_FADE_MODES,
     EMISSION_SHAPES,
     PARTICLE_SHAPES,
+    AlphaFadeMode,
+    EmissionShape,
+    FieldQuality,
+    ParticleShape,
     ParticleSystemConfig,
     parse_particle_dict,
     parse_particle_file,
@@ -105,6 +109,10 @@ __all__ = [
     "ALPHA_FADE_MODES",
     "EMISSION_SHAPES",
     "PARTICLE_SHAPES",
+    "AlphaFadeMode",
+    "EmissionShape",
+    "FieldQuality",
+    "ParticleShape",
     "ParticleSystemConfig",
     "parse_particle_dict",
     "parse_particle_file",

{tilemap_parser-5.0.2 → 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.2 → 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.2 → tilemap_parser-5.0.4}/src/tilemap_parser/parser/particle.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
 import json
+import math
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union, cast, get_args
 
 from .map_parse import (
     JsonDict,
@@ -18,16 +19,21 @@ from .map_parse import (
 )
 
 
+EmissionShape = Literal["point", "rect", "circle", "line"]
+ParticleShape = Literal["circle", "square", "diamond", "star", "sparkle", "smoke", "heart", "line", "fog"]
+AlphaFadeMode = Literal["none", "fade_out", "fade_in", "fade_both"]
+FieldQuality = Literal["low", "medium", "high"]
+
 EMISSION_SHAPES = ["point", "rect", "circle", "line"]
-PARTICLE_SHAPES = ["circle", "square", "diamond", "star", "sparkle", "smoke", "heart", "line"]
-ALPHA_FADE_MODES = ["none", "fade_out", "fade_in", "fade_both"]
+PARTICLE_SHAPES = list(get_args(ParticleShape))
+ALPHA_FADE_MODES = list(get_args(AlphaFadeMode))
 
 
 @dataclass
 class ParticleSystemConfig:
     name: str
-    emission_shape: str = "point"
-    particle_shape: str = "circle"
+    emission_shape: EmissionShape = "point"
+    particle_shape: ParticleShape = "circle"
     particle_size_min: int = 2
     particle_size_max: int = 6
     spawn_rate: int = 20
@@ -51,7 +57,9 @@ class ParticleSystemConfig:
     start_scale: float = 1.0
     end_scale: float = 0.3
     rotation_speed: float = 0.0
-    alpha_fade: str = "fade_out"
+    alpha_fade: AlphaFadeMode = "fade_out"
+    fade_peak_alpha: Optional[int] = None
+    wrap: bool = False
 
     def apply_render_scale(self, scale: float) -> None:
         """Scale dimensionful fields by *scale* (typically ``render_scale``).
@@ -70,8 +78,45 @@ class ParticleSystemConfig:
         self.gravity_x *= scale
         self.gravity_y *= scale
 
+    def fill_area(self, w: float, h: float) -> float:
+        """Effective fill area of the emission shape over a ``w x h`` rect.
+
+        Rect and line fill their whole band; circle fills only the
+        inscribed disc (``pi * (min(w, h) / 2) ** 2``), so density math
+        stays honest for non-rect shapes.  ``point`` has no area and
+        raises.
+        """
+        if self.emission_shape == "circle":
+            radius = min(w, h) / 2
+            return math.pi * radius * radius
+        if self.emission_shape == "point":
+            raise ValueError(
+                "emission_shape 'point' has no fill area; use rect/circle/line "
+                "or a wider emission rect"
+            )
+        return w * h
+
+    def count_for_coverage(self, coverage: float, w: float, h: float) -> int:
+        """Particles needed so sheets cover ``coverage`` of the ``w x h`` area.
+
+        ``coverage`` is dimensionless (0.5 = half the area).  Count is
+        ``coverage * fill_area / mean_particle_area``, where the particle
+        area uses the shape's fill factor (circle sheets are roughly
+        ``pi/4`` of their bounding square; everything else uses the full
+        square).  Not capped by ``max_particles`` — cap it yourself or use
+        ``ParticleSystem.emit_field``, which does.
+        """
+        if coverage <= 0:
+            raise ValueError(f"coverage must be > 0, got {coverage}")
+        mean_size = (self.particle_size_min + self.particle_size_max) / 2
+        if mean_size <= 0:
+            return 0
+        fill = math.pi / 4 if self.particle_shape == "circle" else 1.0
+        area = self.fill_area(w, h)
+        return max(0, round(coverage * area / (mean_size * mean_size * fill)))
+
     def to_dict(self) -> JsonDict:
-        return {
+        d = {
             "emission_shape": self.emission_shape,
             "particle_shape": self.particle_shape,
             "particle_size_min": self.particle_size_min,
@@ -98,7 +143,11 @@ class ParticleSystemConfig:
             "end_scale": self.end_scale,
             "rotation_speed": self.rotation_speed,
             "alpha_fade": self.alpha_fade,
+            "wrap": self.wrap,
         }
+        if self.fade_peak_alpha is not None:
+            d["fade_peak_alpha"] = self.fade_peak_alpha
+        return d
 
     @classmethod
     def from_dict(cls, d: JsonDict, name: str = "") -> "ParticleSystemConfig":
@@ -106,18 +155,18 @@ class ParticleSystemConfig:
             return d.get(key, default)
 
         cfg = cls(name=name)
-        cfg.emission_shape = str(g("emission_shape", "point"))
+        cfg.emission_shape = cast(EmissionShape, str(g("emission_shape", "point")))
         if cfg.emission_shape not in EMISSION_SHAPES:
             cfg.emission_shape = "point"
-        cfg.particle_shape = str(g("particle_shape", "circle"))
+        cfg.particle_shape = cast(ParticleShape, str(g("particle_shape", "circle")))
         if cfg.particle_shape not in PARTICLE_SHAPES:
             cfg.particle_shape = "circle"
-        cfg.alpha_fade = str(g("alpha_fade", "fade_out"))
+        cfg.alpha_fade = cast(AlphaFadeMode, str(g("alpha_fade", "fade_out")))
         if cfg.alpha_fade not in ALPHA_FADE_MODES:
             cfg.alpha_fade = "fade_out"
         cfg.particle_size_min = max(1, int(g("particle_size_min", 2)))
         cfg.particle_size_max = max(cfg.particle_size_min, int(g("particle_size_max", 6)))
-        cfg.spawn_rate = max(1, int(g("spawn_rate", 20)))
+        cfg.spawn_rate = max(0, int(g("spawn_rate", 20)))
         cfg.max_particles = max(1, int(g("max_particles", 100)))
         cfg.lifetime_min = max(0.1, float(g("lifetime_min", 0.5)))
         cfg.lifetime_max = max(cfg.lifetime_min, float(g("lifetime_max", 2.0)))
@@ -138,6 +187,12 @@ class ParticleSystemConfig:
         cfg.start_scale = max(0.1, float(g("start_scale", 1.0)))
         cfg.end_scale = max(0.1, float(g("end_scale", 0.3)))
         cfg.rotation_speed = float(g("rotation_speed", 0))
+        cfg.wrap = bool(g("wrap", False))
+        raw_peak = d.get("fade_peak_alpha")
+        if raw_peak is None:
+            cfg.fade_peak_alpha = None
+        else:
+            cfg.fade_peak_alpha = max(0, min(255, int(raw_peak)))
         return cfg
 
 

{tilemap_parser-5.0.2 → tilemap_parser-5.0.4}/src/tilemap_parser/runtime/__init__.py

@@ -26,9 +26,14 @@ from .renderer import LayerRenderStats, TileLayerRenderer
 from .area_node import AreaNode
 from . import navigation
 from .particles import (
+    FOG_PROFILE,
+    FieldLayerSpec,
+    FieldProfile,
     Particle,
     ParticleEmitter,
     ParticleEmitterNode,
+    ParticleField,
+    ParticleFieldLayer,
     ParticleRenderer,
     ParticleSystem,
     SpriteBatchRenderer,
@@ -64,9 +69,14 @@ __all__ = [
     "load_map_objects",
     "load_object_collision",
     "load_tileset_collision",
+    "FOG_PROFILE",
+    "FieldLayerSpec",
+    "FieldProfile",
     "Particle",
     "ParticleEmitter",
     "ParticleEmitterNode",
+    "ParticleField",
+    "ParticleFieldLayer",
     "ParticleRenderer",
     "ParticleSystem",
     "PhysicsWorld",

{tilemap_parser-5.0.2 → 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,
+    )