tilemap-parser 5.0.0__tar.gz → 5.0.1__tar.gz

{tilemap_parser-5.0.0 → tilemap_parser-5.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 5.0.0
+Version: 5.0.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
@@ -765,6 +765,40 @@ particle_config = ParticleSystemConfig(
 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)
+```
+
+Pushable crates are just kinematic bodies moved with an explicit velocity (gravity is skipped when `velocity=` is given):
+
+```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
+```
+
+`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).
+
 ## Links
 
 - **Docs**: [https://deepwiki.com/FluffyBrudy/tilemap-parser](https://deepwiki.com/FluffyBrudy/tilemap-parser)

{tilemap_parser-5.0.0 → tilemap_parser-5.0.1}/README.md

@@ -66,6 +66,40 @@ particle_config = ParticleSystemConfig(
 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)
+```
+
+Pushable crates are just kinematic bodies moved with an explicit velocity (gravity is skipped when `velocity=` is given):
+
+```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
+```
+
+`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).
+
 ## Links
 
 - **Docs**: [https://deepwiki.com/FluffyBrudy/tilemap-parser](https://deepwiki.com/FluffyBrudy/tilemap-parser)

{tilemap_parser-5.0.0 → tilemap_parser-5.0.1}/pyproject.toml

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

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

{tilemap_parser-5.0.0 → tilemap_parser-5.0.1}/src/tilemap_parser/parser/collision.py

@@ -77,6 +77,44 @@ class TilesetCollision:
             return []
         return [shape.transform(tile_x, tile_y, scale) for shape in tile_data.shapes]
 
+    @classmethod
+    def merge(
+        cls,
+        collisions: List["TilesetCollision"],
+        firstgids: List[int],
+    ) -> "TilesetCollision":
+        """Merge multiple tileset collisions into one, offsetting keys by firstgid.
+
+        Each collision's tiles are re-keyed as ``firstgid + local_id`` so that
+        the resulting dict uses global tile IDs for lookup.
+
+        Args:
+            collisions: List of TilesetCollision objects to merge.
+            firstgids: List of firstgid offsets, one per collision, in the
+                       same order as *collisions*.  The offset is added to
+                       each tile's local ID to produce the global key.
+
+        Usage::
+
+            merged = TilesetCollision.merge([ts0, ts1], [0, 200])
+        """
+        if not collisions:
+            return cls(tileset_name="merged", tile_size=(0, 0))
+        tile_size = collisions[0].tile_size
+        merged_tiles: Dict[int, TileCollisionData] = {}
+        for coll, offset in zip(collisions, firstgids, strict=True):
+            for local_id, data in coll.tiles.items():
+                gid = offset + local_id
+                merged_tiles[gid] = TileCollisionData(
+                    tile_id=gid,
+                    shapes=data.shapes[:],
+                )
+        return cls(
+            tileset_name="merged",
+            tile_size=tile_size,
+            tiles=merged_tiles,
+        )
+
 
 @dataclass
 class RectangleShape:
@@ -211,7 +249,7 @@ def parse_tileset_collision(data: JsonDict) -> TilesetCollision:
             tiles[tile_id] = TileCollisionData(tile_id=tile_id, shapes=shapes)
 
         return TilesetCollision(
-            tileset_name=tileset_name, tile_size=tile_size, tiles=tiles
+            tileset_name=tileset_name, tile_size=tile_size, tiles=tiles,
         )
     except (KeyError, ValueError, TypeError) as e:
         raise CollisionParseError(f"Invalid tileset collision data: {e}") from e

{tilemap_parser-5.0.0 → tilemap_parser-5.0.1}/src/tilemap_parser/parser/map_parse.py

@@ -105,6 +105,7 @@ class ParsedTile:
     pos: Point
     ttype: TilesetRef
     variant: int
+    gid: Optional[int] = None
     properties: Optional[JsonDict] = None
     flip_h: bool = False
     flip_v: bool = False
@@ -142,6 +143,8 @@ class TilesetAnimation:
 class ParsedTileset:
     path: str
     type: str
+    tile_count: int = 0
+    firstgid: int = 0
     properties: JsonDict = field(default_factory=dict)
     tile_properties: Dict[str, JsonDict] = field(default_factory=dict)
     animation: Optional[TilesetAnimation] = None
@@ -156,10 +159,13 @@ class ParsedLayer:
     locked: bool
     opacity: float
     z_index: int
+    y_sort: bool = False
+    y_sort_origin: int = 0
     properties: JsonDict = field(default_factory=dict)
     tiles: Dict[Point, ParsedTile] = field(default_factory=dict)
     objects: Dict[int, ParsedObject] = field(default_factory=dict)
     next_object_id: Optional[int] = None
+    ttypes: set[int] = field(default_factory=set)
 
 
 @dataclass
@@ -217,10 +223,13 @@ def _parse_tile(tile_data: JsonDict, ctx: str) -> ParsedTile:
     else:
         ttype = _coerce_int(ttype_raw, f"{ctx}.ttype")
     props = _optional_dict(tile_data.get("properties"), f"{ctx}.properties")
+    gid_raw = tile_data.get("gid")
+    gid = _coerce_int(gid_raw, f"{ctx}.gid") if gid_raw is not None else None
     return ParsedTile(
         pos=pos,
         ttype=ttype,
         variant=variant,
+        gid=gid,
         properties=props,
         flip_h=tile_data.get("flip_h", False),
         flip_v=tile_data.get("flip_v", False),
@@ -279,6 +288,8 @@ def _parse_layer(layer_obj: JsonDict, layer_id: int, ctx: str) -> ParsedLayer:
         locked=_coerce_bool(layer_obj.get("locked", False), f"{ctx}.locked"),
         opacity=_coerce_float(layer_obj.get("opacity", 1.0), f"{ctx}.opacity"),
         z_index=_coerce_int(layer_obj.get("z_index", layer_id), f"{ctx}.z_index"),
+        y_sort=_coerce_bool(layer_obj.get("y_sort", False), f"{ctx}.y_sort"),
+        y_sort_origin=layer_obj.get("y_sort_origin", 0),
         properties=_optional_dict(layer_obj.get("properties"), f"{ctx}.properties")
         or {},
     )
@@ -291,6 +302,8 @@ def _parse_layer(layer_obj: JsonDict, layer_id: int, ctx: str) -> ParsedLayer:
             _require_dict(layer_obj.get("objects", {}), f"{ctx}.objects"),
             f"{ctx}.objects",
         )
+        for obj in layer.objects.values():
+            layer.ttypes.add(obj.ttype)
         if "next_object_id" in layer_obj and layer_obj["next_object_id"] is not None:
             layer.next_object_id = _coerce_int(
                 layer_obj["next_object_id"], f"{ctx}.next_object_id"
@@ -378,6 +391,8 @@ def _parse_tilesets_list(tilesets_raw: List[Any], ctx: str) -> List[ParsedTilese
             ParsedTileset(
                 path=path, type=ts_type, properties=props, tile_properties=tile_props,
                 animation=animation,
+                tile_count=_coerce_int(ts_obj.get("tile_count", 0), f"{ctx}[{i}].tile_count"),
+                firstgid=_coerce_int(ts_obj.get("firstgid", 0), f"{ctx}[{i}].firstgid"),
             )
         )
     return out
@@ -401,6 +416,7 @@ def _expand_ongrid_to_layer(data_obj: JsonDict, ctx: str) -> List[ParsedLayer]:
         locked=False,
         opacity=1.0,
         z_index=0,
+        y_sort=False, y_sort_origin=0,
         properties={},
     )
     for loc_str, tile_data in raw_ongrid.items():

{tilemap_parser-5.0.0 → tilemap_parser-5.0.1}/src/tilemap_parser/parser/tmx_converter.py

@@ -268,6 +268,7 @@ def _parse_tile_layer(
         locked=False,
         opacity=opacity,
         z_index=0,
+        y_sort=False, y_sort_origin=0,
     )
 
     layer.properties = _parse_properties(layer_elem)

{tilemap_parser-5.0.0 → tilemap_parser-5.0.1}/src/tilemap_parser/runtime/__init__.py

@@ -1,5 +1,7 @@
 from .camera import Camera
 from .animation_player import AnimationPlayer, SpriteAnimationSet
+from .body import Body
+from .world import PhysicsWorld
 from .collision_cache import (
     CollisionCache,
     clear_collision_cache,
@@ -10,22 +12,19 @@ from .collision_cache import (
     load_object_collision,
     load_tileset_collision,
 )
-from .tile_collision import (
-    CollisionResult,
-    CollisionRunner,
-    ICollidableSprite,
-    MovementMode,
-    rect_vs_tilemap,
-)
+from .map_object import MapObject, load_map_objects
+from .movement import CollisionResult, CollisionRunner, MovementMode
+from .polygon_query import rect_vs_tilemap
+from .protocols import ICollidable, ICollidableObject, ICollidableSprite
 from .map_loader import TilemapData, load_map
-from .object_collision import (
+from .collision import (
     CollisionHit,
-    ICollidableObject,
     ObjectCollisionManager,
     check_collision,
 )
 from .renderer import LayerRenderStats, TileLayerRenderer
 from .area_node import AreaNode
+from . import navigation
 from .particles import (
     Particle,
     ParticleEmitter,
@@ -39,14 +38,17 @@ from .particles import (
 __all__ = [
     "AnimationPlayer",
     "AreaNode",
+    "Body",
     "Camera",
     "CollisionCache",
     "CollisionHit",
     "CollisionResult",
     "CollisionRunner",
+    "ICollidable",
     "ICollidableObject",
     "ICollidableSprite",
     "LayerRenderStats",
+    "MapObject",
     "MovementMode",
     "ObjectCollisionManager",
     "SpriteAnimationSet",
@@ -59,6 +61,7 @@ __all__ = [
     "get_cached_tileset_collision",
     "load_character_collision",
     "load_map",
+    "load_map_objects",
     "load_object_collision",
     "load_tileset_collision",
     "Particle",
@@ -66,6 +69,7 @@ __all__ = [
     "ParticleEmitterNode",
     "ParticleRenderer",
     "ParticleSystem",
+    "PhysicsWorld",
     "rect_vs_tilemap",
     "SpriteBatchRenderer",
     "clear_texture_caches",

{tilemap_parser-5.0.0 → tilemap_parser-5.0.1}/src/tilemap_parser/runtime/area_node.py

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

tilemap_parser-5.0.1/src/tilemap_parser/runtime/body.py

@@ -0,0 +1,198 @@
+"""Physics bodies authored into a :class:`~.world.PhysicsWorld`.
+
+A :class:`Body` is the authoring surface for a solid in the world.  It owns
+a single primitive collision shape (rectangle, circle, or capsule — polygon
+shapes stay in the ``MapObject`` lane) plus its position and velocity, and
+participates in collision detection through the same
+``ICollidableObject`` contract as :class:`~.map_object.MapObject`
+(owner-local shape, ``obj.x + vertex`` applied once by the narrowphase).
+
+Bodies are NOT self-moving.  ``mode == "kinematic"`` marks a body the game
+moves explicitly each frame (e.g. a crate pushed with ``move_grounded``);
+``mode == "static"`` marks a body that never moves (e.g. scenery, furniture).
+Neither mode implies physics-engine dynamics — velocity is scripted, Godot
+``StaticBody2D`` / ``CharacterBody2D`` style.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Optional, Tuple
+
+from ..parser.collision import (
+    CapsuleShape,
+    CircleShape,
+    CollisionPolygon,
+    RectangleShape,
+)
+
+BodyMode = str  # "static" | "kinematic"
+
+BODY_MODES = ("static", "kinematic")
+
+BodyShape = RectangleShape | CircleShape | CapsuleShape
+
+
+class Body:
+    """A solid body with a single primitive collision shape."""
+
+    __slots__ = (
+        "collision_layer",
+        "collision_mask",
+        "collision_shape",
+        "game_id",
+        "mode",
+        "on_ground",
+        "vx",
+        "vy",
+        "x",
+        "y",
+    )
+
+    def __init__(
+        self,
+        collision_shape: BodyShape,
+        x: float = 0.0,
+        y: float = 0.0,
+        *,
+        vx: float = 0.0,
+        vy: float = 0.0,
+        mode: BodyMode = "static",
+        collision_layer: int = 1,
+        collision_mask: int = 0xFFFFFFFF,
+        game_id: str = "",
+    ):
+        """
+        Create a body.
+
+        Args:
+            collision_shape: Primitive shape (RectangleShape, CircleShape,
+                or CapsuleShape).  Polygon shapes are not supported on
+                bodies — use :class:`MapObject` for polygon solids.
+            x: World X position of the shape origin (top-left / center
+                per shape offset semantics).
+            y: World Y position.
+            vx: X velocity (for kinematic bodies).
+            vy: Y velocity (for kinematic bodies).
+            mode: ``"static"`` (never moves) or ``"kinematic"`` (moved
+                explicitly by the game).
+            collision_layer: Layer this body is on (default 1).
+            collision_mask: Layers this body collides with (default all).
+            game_id: Optional label for debugging.
+        """
+        if not isinstance(collision_shape, (RectangleShape, CircleShape, CapsuleShape)):
+            raise TypeError(
+                "Body requires a primitive shape (RectangleShape, CircleShape, "
+                f"or CapsuleShape), got {type(collision_shape).__name__}"
+            )
+        if mode not in BODY_MODES:
+            raise ValueError(
+                f"mode must be one of {BODY_MODES}, got {mode!r}"
+            )
+        self.collision_shape = collision_shape
+        self.x = x
+        self.y = y
+        self.vx = vx
+        self.vy = vy
+        self.mode = mode
+        self.collision_layer = collision_layer
+        self.collision_mask = collision_mask
+        self.game_id = game_id
+        self.on_ground = False
+
+    def __repr__(self) -> str:
+        return (
+            f"Body(shape={type(self.collision_shape).__name__}, x={self.x}, "
+            f"y={self.y}, mode={self.mode!r}, game_id={self.game_id!r})"
+        )
+
+    # ------------------------------------------------------------------
+    # Geometry helpers used by the movement resolver
+    # ------------------------------------------------------------------
+
+    def top_y_at(self, world_x: float) -> Optional[float]:
+        """Return the top-surface world Y of this body at *world_x*, or None.
+
+        Only the top surface is sampled — bodies are never one-way, but the
+        resolver only needs the topmost surface for ground landing.
+        """
+        shape = self.collision_shape
+        if isinstance(shape, RectangleShape):
+            left = self.x + shape.offset[0]
+            if left <= world_x <= left + shape.width:
+                return self.y + shape.offset[1]
+            return None
+
+        if isinstance(shape, CircleShape):
+            cx = self.x + shape.offset[0]
+            cy = self.y + shape.offset[1]
+            return _circle_top_y(cx, cy, shape.radius, world_x)
+
+        # CapsuleShape — vertical segment (top cap center, radius, height)
+        px = self.x + shape.offset[0]
+        py = self.y + shape.offset[1]
+        return _circle_top_y(px, py, shape.radius, world_x)
+
+    def as_polygon(self) -> CollisionPolygon:
+        """World-space polygon approximation of this body's shape.
+
+        Used only by slide-mode normal computation (the tile resolver works
+        on polygon edges).  Circles/capsules are approximated with enough
+        edges that the closest-edge normal is visually exact.
+        """
+        shape = self.collision_shape
+        if isinstance(shape, RectangleShape):
+            left = self.x + shape.offset[0]
+            top = self.y + shape.offset[1]
+            return CollisionPolygon(
+                vertices=[
+                    (left, top),
+                    (left + shape.width, top),
+                    (left + shape.width, top + shape.height),
+                    (left, top + shape.height),
+                ]
+            )
+
+        if isinstance(shape, CircleShape):
+            cx = self.x + shape.offset[0]
+            cy = self.y + shape.offset[1]
+            return CollisionPolygon(
+                vertices=_ngon(cx, cy, shape.radius, 16)
+            )
+
+        # Capsule — top cap semicircle, implicit side edges, bottom cap
+        px = self.x + shape.offset[0]
+        py = self.y + shape.offset[1]
+        bx = px
+        by = py + shape.height
+        r = shape.radius
+        steps = 4
+        verts: list[Tuple[float, float]] = []
+        # Top cap — left (pi) to right (0) through the top (3pi/2 = up)
+        for k in range(steps + 1):
+            a = math.pi + (math.pi * k / steps)
+            verts.append((px + r * math.cos(a), py + r * math.sin(a)))
+        # Bottom cap — right (0) to left (pi) through the bottom (pi/2 = down)
+        for k in range(steps + 1):
+            a = math.pi * k / steps
+            verts.append((bx + r * math.cos(a), by + r * math.sin(a)))
+        return CollisionPolygon(vertices=verts)
+
+
+def _circle_top_y(cx: float, cy: float, radius: float, world_x: float) -> Optional[float]:
+    """Top-surface Y of a circle at *world_x* (upper semicircle), or None."""
+    dx = world_x - cx
+    if abs(dx) > radius:
+        return None
+    return cy - math.sqrt(radius * radius - dx * dx)
+
+
+def _ngon(cx: float, cy: float, radius: float, edges: int) -> list[Tuple[float, float]]:
+    """Vertices of a regular polygon approximating a circle."""
+    return [
+        (
+            cx + radius * math.cos(2 * math.pi * i / edges),
+            cy + radius * math.sin(2 * math.pi * i / edges),
+        )
+        for i in range(edges)
+    ]

tilemap_parser-5.0.1/src/tilemap_parser/runtime/collision/__init__.py

@@ -0,0 +1,10 @@
+"""Object-to-object collision package.
+
+Shape-level narrowphase lives in :mod:`shapes`, hit results and pair
+queries in :mod:`hit`, and the spatial-grid manager in :mod:`manager`.
+"""
+
+from .hit import CollisionHit, check_collision, should_collide
+from .manager import ObjectCollisionManager
+
+__all__ = ["CollisionHit", "ObjectCollisionManager", "check_collision", "should_collide"]