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

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

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

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

@@ -10,6 +10,7 @@ from .collision_cache import (
     load_object_collision,
     load_tileset_collision,
 )
+from .map_object import MapObject, load_map_objects
 from .tile_collision import (
     CollisionResult,
     CollisionRunner,
@@ -47,6 +48,7 @@ __all__ = [
     "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",

{tilemap_parser-4.2.0 → tilemap_parser-4.2.1}/src/tilemap_parser/runtime/map_loader.py

@@ -68,7 +68,12 @@ class TilemapData:
                 surfaces.append(None)
                 continue
             try:
-                surfaces.append(pygame.image.load(str(resolved)).convert_alpha())
+                surf = pygame.image.load(str(resolved))
+                try:
+                    surf = surf.convert_alpha()
+                except pygame.error:
+                    pass
+                surfaces.append(surf)
             except pygame.error as e:
                 msg = f"Tileset load failed ({i}) {resolved}: {e}"
                 warnings.append(msg)
@@ -244,6 +249,16 @@ class TilemapData:
             return None
         return _variant_surface(source, variant, self.tile_size, copy_surface=copy_surface)
 
+    def get_object_surface(self, obj: ParsedObject, *, copy_surface: bool = True) -> Optional[Surface]:
+        if obj.ttype < 0 or obj.ttype >= len(self.surfaces):
+            return None
+        source = self.surfaces[obj.ttype]
+        if source is None:
+            return None
+        if (obj.area.w, obj.area.h) == (source.get_width(), source.get_height()):
+            return source.copy() if copy_surface else source
+        return _variant_surface(source, obj.variant, self.tile_size, copy_surface=copy_surface)
+
     def get_tile_surface(self, ttype: int, variant: int, *, copy_surface: bool = True) -> Optional[Surface]:
         return self.get_image(variant=variant, ttype=ttype, copy_surface=copy_surface)
 
@@ -259,9 +274,6 @@ class TilemapData:
             return None
         return self.get_tile_surface(tile.ttype, tile.variant)
 
-    def get_object_surface(self, obj: ParsedObject, *, copy_surface: bool = True) -> Optional[Surface]:
-        return self.get_image(variant=obj.variant, ttype=obj.ttype, copy_surface=copy_surface)
-
     def get_object_surface_by_id(
         self, layer_id_or_name: Union[int, str], object_id: int, *, copy_surface: bool = True
     ) -> Optional[Tuple[Surface, int, int]]:

tilemap_parser-4.2.1/src/tilemap_parser/runtime/map_object.py

@@ -0,0 +1,181 @@
+"""
+Runtime map object loading and representation.
+
+Bridges the gap between parsed map objects, collision data, and
+the collision manager.  Provides a ready-to-use :class:`MapObject`
+that implements :class:`ICollidableObject` and carries a pygame
+:class:`~pygame.Surface` for rendering.
+
+Usage::
+
+    objects = load_map_objects(tilemap_data, MAPS_PATH / "collision")
+    for obj in objects:
+        collision_manager.add_object(obj)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Dict, List, Optional, Union
+
+from pygame import Surface
+
+from ..parser.collision import CollisionPolygon, ObjectCollisionData
+from ..parser.collision_loader import load_object_collision
+from .collision_cache import CollisionCache
+from .map_loader import TilemapData
+
+
+class MapObject:
+    """
+    A game object loaded from a tilemap, carrying a surface for
+    rendering and collision data for physics.
+
+    Satisfies the :class:`ICollidableObject` protocol so it can be
+    added directly to an :class:`ObjectCollisionManager`.
+
+    When a region contains multiple disjoint polygons, *all* shapes
+    are stored in :attr:`collision_shapes` and the first shape is
+    used as :attr:`collision_shape` for protocol compatibility.
+    The collision system (:func:`check_collision`) iterates all
+    shape pairs when either object has multiple shapes.
+    """
+
+    __slots__ = (
+        "x",
+        "y",
+        "surface",
+        "collision_shape",
+        "collision_shapes",
+        "collision_layer",
+        "collision_mask",
+    )
+
+    def __init__(
+        self,
+        x: float,
+        y: float,
+        surface: Surface,
+        collision_shape: CollisionPolygon,
+        *,
+        collision_shapes: Optional[List[CollisionPolygon]] = None,
+        collision_layer: int = 1,
+        collision_mask: int = 0xFFFFFFFF,
+    ) -> None:
+        self.x = x
+        self.y = y
+        self.surface = surface
+        self.collision_shapes = collision_shapes or [collision_shape]
+        self.collision_shape = self.collision_shapes[0]
+        self.collision_layer = collision_layer
+        self.collision_mask = collision_mask
+
+
+def _resolve_object_collision_filename(tileset_path: Union[str, Path]) -> str:
+    """Extract the object collision filename for a given tileset path.
+
+    Example: ``"building7.png"`` → ``"building7.object_collision.json"``
+    """
+    return f"{Path(tileset_path).stem}.object_collision.json"
+
+
+def load_map_objects(
+    tilemap_data: TilemapData,
+    collision_dir: Union[str, Path],
+    *,
+    cache: Optional[CollisionCache] = None,
+) -> List[MapObject]:
+    """Load all collidable objects from a tilemap.
+
+    Iterates every object layer in *tilemap_data*, resolves the
+    corresponding ``.object_collision.json`` from *collision_dir*, and
+    builds :class:`MapObject` instances with surfaces, owner-local
+    collision shapes (region offset only; consumers add x/y), and
+    layer/mask values from the collision regions.
+
+    Collision data is cached per tileset index so the same file is
+    never loaded twice.
+
+    Args:
+        tilemap_data: Loaded tilemap data (surfaces, tilesets, layers).
+        collision_dir: Directory containing ``*.object_collision.json``
+            files (typically ``<map_path>/collision/``).
+        cache: Optional :class:`CollisionCache` for caching parsed
+            collision data across calls.
+
+    Returns:
+        List of :class:`MapObject` instances, one per map object that
+        has both a valid surface and a matching collision region.
+        When a region contains multiple collision polygons, all shapes
+        are preserved in :attr:`MapObject.collision_shapes` and the
+        collision system checks each shape pair during narrowphase.
+    """
+    collision_dir = Path(collision_dir)
+    objects: List[MapObject] = []
+    object_layers = tilemap_data.get_layers(layer_type="object")
+
+    loaded_collision: Dict[int, Optional[ObjectCollisionData]] = {}
+
+    for layer in object_layers:
+        for obj_id, obj in layer.objects.items():
+            surf_x_y = tilemap_data.get_object_surface_by_id(layer.id, obj_id)
+            if surf_x_y is None:
+                continue
+
+            surf, x, y = surf_x_y
+
+            ttype = obj.ttype
+            if ttype not in loaded_collision:
+                collision_data = _load_collision_for_tileset(
+                    tilemap_data, ttype, collision_dir, cache
+                )
+                loaded_collision[ttype] = collision_data
+
+            collision_data = loaded_collision[ttype]
+            if collision_data is None:
+                continue
+
+            world_shapes = []
+            region_layer = 1
+            region_mask = 0xFFFFFFFF
+            for region in collision_data.regions.values():
+                if not world_shapes:
+                    region_layer = region.collision_layer
+                    region_mask = region.collision_mask
+                ox = region.region_rect[0]
+                oy = region.region_rect[1]
+                world_shapes.extend(shape.transform(ox, oy) for shape in region.shapes)
+            if not world_shapes:
+                continue
+
+            game_obj = MapObject(
+                x=x,
+                y=y,
+                surface=surf,
+                collision_shape=world_shapes[0],
+                collision_shapes=world_shapes,
+                collision_layer=region_layer,
+                collision_mask=region_mask,
+            )
+            objects.append(game_obj)
+
+    return objects
+
+
+def _load_collision_for_tileset(
+    tilemap_data: TilemapData,
+    ttype: int,
+    collision_dir: Path,
+    cache: Optional[CollisionCache],
+) -> Optional[ObjectCollisionData]:
+    """Load (or retrieve from cache) collision data for a tileset index."""
+    if ttype < 0 or ttype >= len(tilemap_data.parsed.tilesets):
+        return None
+
+    tileset_path = tilemap_data.parsed.tilesets[ttype].path
+    coll_filename = _resolve_object_collision_filename(tileset_path)
+    coll_path = collision_dir / coll_filename
+
+    if cache is not None:
+        return cache.get_object_collision(coll_path)
+    return load_object_collision(coll_path)

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

@@ -133,96 +133,89 @@ def should_collide(
 _should_collide = should_collide
 
 
-def check_collision(
-    obj_a: ICollidableObject,
-    obj_b: ICollidableObject,
-) -> Optional[CollisionHit]:
-    """
-    Check if two objects collide.
+def _get_shapes(obj: ICollidableObject) -> List:
+    """Return all collision shapes for an object.
 
-    Pipeline:
-        1. Layer filtering
-        2. Broadphase AABB rejection
-        3. Narrowphase geometry dispatch
-        4. Return CollisionHit or None
-
-    All shape combinations are supported, including polygon-vs-anything.
+    Objects with a :attr:`collision_shapes` attribute (e.g.
+    :class:`MapObject`) may carry multiple polygons per region;
+    single-shape objects return ``[obj.collision_shape]``.
     """
-    # 1. Layer filter
-    if not should_collide(obj_a, obj_b):
-        return None
-
-    # 2. Broadphase
-    aabb_a = get_shape_aabb(obj_a.x, obj_a.y, obj_a.collision_shape)
-    aabb_b = get_shape_aabb(obj_b.x, obj_b.y, obj_b.collision_shape)
-    if not aabb_overlap(aabb_a, aabb_b):
-        return None
-
-    # 3. Narrowphase dispatch
-    shape_a = obj_a.collision_shape
-    shape_b = obj_b.collision_shape
-
-    info: Optional[CollisionInfo] = None
-
+    shapes = getattr(obj, "collision_shapes", None)
+    if shapes is not None and len(shapes) > 0:
+        return list(shapes)
+    return [obj.collision_shape]
+
+
+def _combined_aabb(x: float, y: float, shapes: List) -> tuple[float, float, float, float]:
+    """Union AABB across all shapes at position *(x, y)*."""
+    left = top = float("inf")
+    right = bottom = float("-inf")
+    for shape in shapes:
+        sx0, sy0, sx1, sy1 = get_shape_aabb(x, y, shape)
+        if sx0 < left:
+            left = sx0
+        if sy0 < top:
+            top = sy0
+        if sx1 > right:
+            right = sx1
+        if sy1 > bottom:
+            bottom = sy1
+    return (left, top, right, bottom)
+
+
+def _check_pair(
+    obj_a: ICollidableObject,
+    obj_b: ICollidableObject,
+    shape_a,
+    shape_b,
+    aabb_a: tuple[float, float, float, float],
+    aabb_b: tuple[float, float, float, float],
+) -> Optional[CollisionInfo]:
+    """Run narrowphase for a single shape pair.  (Extracted from
+    :func:`check_collision` for reuse in the multi-shape loop.)"""
     if isinstance(shape_a, CircleShape) and isinstance(shape_b, CircleShape):
         ca = (obj_a.x + shape_a.offset[0], obj_a.y + shape_a.offset[1])
         cb = (obj_b.x + shape_b.offset[0], obj_b.y + shape_b.offset[1])
-        info = circle_vs_circle(ca, shape_a.radius, cb, shape_b.radius)
+        return circle_vs_circle(ca, shape_a.radius, cb, shape_b.radius)
 
     elif isinstance(shape_a, RectangleShape) and isinstance(shape_b, RectangleShape):
-        info = rect_vs_rect(aabb_a, aabb_b)
+        return rect_vs_rect(aabb_a, aabb_b)
 
     elif isinstance(shape_a, RectangleShape) and isinstance(shape_b, CircleShape):
         cb = (obj_b.x + shape_b.offset[0], obj_b.y + shape_b.offset[1])
-        info = rect_vs_circle(aabb_a, cb, shape_b.radius)
+        return rect_vs_circle(aabb_a, cb, shape_b.radius)
 
     elif isinstance(shape_a, CircleShape) and isinstance(shape_b, RectangleShape):
         ca = (obj_a.x + shape_a.offset[0], obj_a.y + shape_a.offset[1])
-        result = rect_vs_circle(aabb_b, ca, shape_a.radius)
-        if result is not None:
-            # Flip normal: was rect→circle, need circle→rect
-            info = CollisionInfo(
-                normal=(-result.normal[0], -result.normal[1]),
-                depth=result.depth,
-            )
+        return _flip_result(rect_vs_circle(aabb_b, ca, shape_a.radius))
 
     # Polygon vs Polygon
     elif isinstance(shape_a, CollisionPolygon) and isinstance(shape_b, CollisionPolygon):
         verts_a = [(obj_a.x + v[0], obj_a.y + v[1]) for v in shape_a.vertices]
         verts_b = [(obj_b.x + v[0], obj_b.y + v[1]) for v in shape_b.vertices]
-        info = polygon_vs_polygon(verts_a, verts_b)
+        return polygon_vs_polygon(verts_a, verts_b)
 
     # Polygon vs Circle
     elif isinstance(shape_a, CollisionPolygon) and isinstance(shape_b, CircleShape):
         verts_a = [(obj_a.x + v[0], obj_a.y + v[1]) for v in shape_a.vertices]
         center_b = (obj_b.x + shape_b.offset[0], obj_b.y + shape_b.offset[1])
-        info = polygon_vs_circle(verts_a, center_b, shape_b.radius)
+        return polygon_vs_circle(verts_a, center_b, shape_b.radius)
 
     # Circle vs Polygon (flip normal)
     elif isinstance(shape_a, CircleShape) and isinstance(shape_b, CollisionPolygon):
         verts_b = [(obj_b.x + v[0], obj_b.y + v[1]) for v in shape_b.vertices]
         center_a = (obj_a.x + shape_a.offset[0], obj_a.y + shape_a.offset[1])
-        result = polygon_vs_circle(verts_b, center_a, shape_a.radius)
-        if result is not None:
-            info = CollisionInfo(
-                normal=(-result.normal[0], -result.normal[1]),
-                depth=result.depth,
-            )
+        return _flip_result(polygon_vs_circle(verts_b, center_a, shape_a.radius))
 
     # Polygon vs Rect
     elif isinstance(shape_a, CollisionPolygon) and isinstance(shape_b, RectangleShape):
         verts_a = [(obj_a.x + v[0], obj_a.y + v[1]) for v in shape_a.vertices]
-        info = polygon_vs_rect(verts_a, aabb_b)
+        return polygon_vs_rect(verts_a, aabb_b)
 
     # Rect vs Polygon (flip normal)
     elif isinstance(shape_a, RectangleShape) and isinstance(shape_b, CollisionPolygon):
         verts_b = [(obj_b.x + v[0], obj_b.y + v[1]) for v in shape_b.vertices]
-        result = polygon_vs_rect(verts_b, aabb_a)
-        if result is not None:
-            info = CollisionInfo(
-                normal=(-result.normal[0], -result.normal[1]),
-                depth=result.depth,
-            )
+        return _flip_result(polygon_vs_rect(verts_b, aabb_a))
 
     # Capsule pairs
     elif isinstance(shape_a, CapsuleShape) and isinstance(shape_b, CapsuleShape):
@@ -230,73 +223,121 @@ def check_collision(
         p2 = (p1[0], p1[1] + shape_a.height)
         q1 = (obj_b.x + shape_b.offset[0], obj_b.y + shape_b.offset[1])
         q2 = (q1[0], q1[1] + shape_b.height)
-        info = capsule_vs_capsule(p1, p2, shape_a.radius, q1, q2, shape_b.radius)
+        return capsule_vs_capsule(p1, p2, shape_a.radius, q1, q2, shape_b.radius)
 
     elif isinstance(shape_a, CapsuleShape) and isinstance(shape_b, CircleShape):
         p1 = (obj_a.x + shape_a.offset[0], obj_a.y + shape_a.offset[1])
         p2 = (p1[0], p1[1] + shape_a.height)
         cb = (obj_b.x + shape_b.offset[0], obj_b.y + shape_b.offset[1])
-        info = capsule_vs_circle(p1, p2, shape_a.radius, cb, shape_b.radius)
+        return capsule_vs_circle(p1, p2, shape_a.radius, cb, shape_b.radius)
 
     elif isinstance(shape_a, CircleShape) and isinstance(shape_b, CapsuleShape):
         ca = (obj_a.x + shape_a.offset[0], obj_a.y + shape_a.offset[1])
         q1 = (obj_b.x + shape_b.offset[0], obj_b.y + shape_b.offset[1])
         q2 = (q1[0], q1[1] + shape_b.height)
-        result = capsule_vs_circle(q1, q2, shape_b.radius, ca, shape_a.radius)
-        if result is not None:
-            info = CollisionInfo(
-                normal=(-result.normal[0], -result.normal[1]),
-                depth=result.depth,
-            )
+        return _flip_result(capsule_vs_circle(q1, q2, shape_b.radius, ca, shape_a.radius))
 
     elif isinstance(shape_a, CapsuleShape) and isinstance(shape_b, RectangleShape):
         p1 = (obj_a.x + shape_a.offset[0], obj_a.y + shape_a.offset[1])
         p2 = (p1[0], p1[1] + shape_a.height)
-        info = capsule_vs_rect(p1, p2, shape_a.radius, aabb_b)
+        return capsule_vs_rect(p1, p2, shape_a.radius, aabb_b)
 
     elif isinstance(shape_a, RectangleShape) and isinstance(shape_b, CapsuleShape):
         q1 = (obj_b.x + shape_b.offset[0], obj_b.y + shape_b.offset[1])
         q2 = (q1[0], q1[1] + shape_b.height)
-        result = capsule_vs_rect(q1, q2, shape_b.radius, aabb_a)
-        if result is not None:
-            info = CollisionInfo(
-                normal=(-result.normal[0], -result.normal[1]),
-                depth=result.depth,
-            )
+        return _flip_result(capsule_vs_rect(q1, q2, shape_b.radius, aabb_a))
 
     elif isinstance(shape_a, CapsuleShape) and isinstance(shape_b, CollisionPolygon):
         p1 = (obj_a.x + shape_a.offset[0], obj_a.y + shape_a.offset[1])
         p2 = (p1[0], p1[1] + shape_a.height)
         verts_b = [(obj_b.x + v[0], obj_b.y + v[1]) for v in shape_b.vertices]
-        info = capsule_vs_polygon(p1, p2, shape_a.radius, verts_b)
+        return capsule_vs_polygon(p1, p2, shape_a.radius, verts_b)
 
     elif isinstance(shape_a, CollisionPolygon) and isinstance(shape_b, CapsuleShape):
         verts_a = [(obj_a.x + v[0], obj_a.y + v[1]) for v in shape_a.vertices]
         q1 = (obj_b.x + shape_b.offset[0], obj_b.y + shape_b.offset[1])
         q2 = (q1[0], q1[1] + shape_b.height)
-        result = capsule_vs_polygon(q1, q2, shape_b.radius, verts_a)
-        if result is not None:
-            info = CollisionInfo(
-                normal=(-result.normal[0], -result.normal[1]),
-                depth=result.depth,
-            )
+        return _flip_result(capsule_vs_polygon(q1, q2, shape_b.radius, verts_a))
 
     else:
         warnings.warn(
             f"Unhandled collision shape pair: {type(shape_a).__name__} vs {type(shape_b).__name__}",
             UserWarning,
-            stacklevel=2,
+            stacklevel=3,
         )
         return None
 
+
+def _flip_result(info: Optional[CollisionInfo]) -> Optional[CollisionInfo]:
+    """Flip the normal of a :class:`CollisionInfo` in place."""
     if info is None:
         return None
+    return CollisionInfo(
+        normal=(-info.normal[0], -info.normal[1]),
+        depth=info.depth,
+    )
+
+
+def check_collision(
+    obj_a: ICollidableObject,
+    obj_b: ICollidableObject,
+) -> Optional[CollisionHit]:
+    """
+    Check if two objects collide.
+
+    Pipeline:
+        1. Layer filtering
+        2. Broadphase AABB rejection
+        3. Narrowphase geometry dispatch
+        4. Return CollisionHit or None
+
+    Supports multi-shape objects (those with a ``collision_shapes``
+    attribute).  When both objects have a single shape the behaviour
+    is identical to previous versions.
+    """
+    # 1. Layer filter
+    if not should_collide(obj_a, obj_b):
+        return None
+
+    # 2. Broadphase — use combined AABB when an object has multiple shapes
+    shapes_a = _get_shapes(obj_a)
+    shapes_b = _get_shapes(obj_b)
+
+    if len(shapes_a) == 1:
+        aabb_a = get_shape_aabb(obj_a.x, obj_a.y, shapes_a[0])
+    else:
+        aabb_a = _combined_aabb(obj_a.x, obj_a.y, shapes_a)
+
+    if len(shapes_b) == 1:
+        aabb_b = get_shape_aabb(obj_b.x, obj_b.y, shapes_b[0])
+    else:
+        aabb_b = _combined_aabb(obj_b.x, obj_b.y, shapes_b)
+
+    if not aabb_overlap(aabb_a, aabb_b):
+        return None
+
+    # 3. Narrowphase — iterate all shape pairs, keep the deepest
+    deepest: Optional[CollisionInfo] = None
+
+    for shape_a in shapes_a:
+        for shape_b in shapes_b:
+            pair_aabb_a = get_shape_aabb(obj_a.x, obj_a.y, shape_a)
+            pair_aabb_b = get_shape_aabb(obj_b.x, obj_b.y, shape_b)
+            if not aabb_overlap(pair_aabb_a, pair_aabb_b):
+                continue
+
+            info = _check_pair(obj_a, obj_b, shape_a, shape_b, pair_aabb_a, pair_aabb_b)
+            if info is not None and (deepest is None or info.depth > deepest.depth):
+                deepest = info
+
+    if deepest is None:
+        return None
 
     return CollisionHit(
         object_a=obj_a,
         object_b=obj_b,
-        normal=info.normal,
-        depth=info.depth,
+        normal=deepest.normal,
+        depth=deepest.depth,
     )
 
 
@@ -392,7 +433,10 @@ class ObjectCollisionManager:
         self,
         obj: ICollidableObject,
     ) -> tuple[float, float, float, float]:
-        return get_shape_aabb(obj.x, obj.y, obj.collision_shape)
+        shapes = _get_shapes(obj)
+        if len(shapes) == 1:
+            return get_shape_aabb(obj.x, obj.y, shapes[0])
+        return _combined_aabb(obj.x, obj.y, shapes)
 
     def _build_spatial_index(
         self,

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

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

@@ -21,6 +21,7 @@ src/tilemap_parser/runtime/area_node.py
 src/tilemap_parser/runtime/camera.py
 src/tilemap_parser/runtime/collision_cache.py
 src/tilemap_parser/runtime/map_loader.py
+src/tilemap_parser/runtime/map_object.py
 src/tilemap_parser/runtime/object_collision.py
 src/tilemap_parser/runtime/particles.py
 src/tilemap_parser/runtime/renderer.py
@@ -35,6 +36,7 @@ tests/test_integration_animation.py
 tests/test_integration_collision.py
 tests/test_integration_map_loader.py
 tests/test_map_loader.py
+tests/test_map_object.py
 tests/test_move_grounded.py
 tests/test_object_collision.py
 tests/test_object_surfaces.py