tilemap-parser 4.2.0__py3-none-any.whl → 4.2.2__py3-none-any.whl

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/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/runtime/map_object.py

@@ -0,0 +1,212 @@
+"""
+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
+
+import pygame
+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.
+
+    All spatial data (``x``, ``y``, ``surface`` size, and collision
+    polygon vertices) is pre-scaled by the map's ``render_scale``.
+    Units are in *effective* pixels (``render_scale × tile_size``).
+    The object is ready for direct use in a game loop that runs in
+    effective-pixel space — no additional scaling needed.
+
+    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 pre-scaled surfaces,
+    positions, and collision shapes.
+
+    **render_scale transparency**
+
+    All spatial data is automatically scaled by the map's
+    ``render_scale`` (from ``tilemap_data.render_scale``):
+
+    * ``MapObject.x`` / ``MapObject.y`` — raw map coords × ``rs``
+      (stored as ``float``; fractional pixel positions are preserved).
+    * ``MapObject.surface`` — surface is scaled by ``rs`` via
+      :func:`pygame.transform.scale` (no-op when ``rs == 1.0``).
+      Raster dimensions are truncated to integers via ``int()``
+      to satisfy :func:`pygame.transform.scale` requirements.
+    * Collision polygon vertices and ``region_rect`` offsets are
+      multiplied by ``rs`` via :meth:`CollisionPolygon.transform`.
+
+    The returned objects are ready for a game loop that runs in
+    effective-pixel space (``render_scale × tile_size``).  No
+    additional scaling is required by the caller.
+
+    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
+            rs = tilemap_data.render_scale
+            x = x * rs
+            y = y * rs
+
+            if rs != 1.0 and surf is not None:
+                w, h = surf.get_size()
+                surf = pygame.transform.scale(surf, (int(w * rs), int(h * rs)))
+
+            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] * rs
+                oy = region.region_rect[1] * rs
+                world_shapes.extend(shape.transform(ox, oy, rs) 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/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.dist-info → tilemap_parser-4.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 4.2.0
+Version: 4.2.2
 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.dist-info → tilemap_parser-4.2.2.dist-info}/RECORD

@@ -7,20 +7,21 @@ tilemap_parser/parser/map_parse.py,sha256=0P8ubprY3eyV34Kpo8eQWabCwlywRFd48y9Kwa
 tilemap_parser/parser/node_parse.py,sha256=KJopNR4fOhAezJly8ZaKB0gpXJ9rQAVwYE23Yc2OfsE,2301
 tilemap_parser/parser/particle.py,sha256=DZxRJcM8EwGAL7OmHwcVcINjDS1-apVJHG1h4Xd5xqk,6722
 tilemap_parser/parser/tmx_converter.py,sha256=-gslroiPocoCZ882duuc1Xxw8RkgcVzs8Fdy0uJqVDY,14006
-tilemap_parser/runtime/__init__.py,sha256=IntqAi1vc_0sWqLnH9ySN8IN7E4govNhxXwOhlNBhy0,1745
+tilemap_parser/runtime/__init__.py,sha256=nX8yCAPMFCAkRoBrs39bCvSnugxnWd-BuQwv0CyV-A4,1838
 tilemap_parser/runtime/animation_player.py,sha256=VwYQjp12oe07uNyWiSWU2YPJPwSrbg9A_dL2rWzGThE,5648
 tilemap_parser/runtime/area_node.py,sha256=gLxpKnO5PumtZ0HzWHl9Osqgp2fzbF2L4ZbNxTY-HH4,1078
 tilemap_parser/runtime/camera.py,sha256=UXHN0cRvhbiA0soCinu357S5FpynT0cAYENURax4Ti8,5016
 tilemap_parser/runtime/collision_cache.py,sha256=fMDGPuyRjddL8KjUnn95iGE-RlK-PaGa3Pzh80z0lAg,4751
-tilemap_parser/runtime/map_loader.py,sha256=59HTLet0otmCD_4eO6p6T8njYEwOrc7jNVc0qdQTH3k,15813
-tilemap_parser/runtime/object_collision.py,sha256=qX8eImFzVab-MBfq1Rq0rnLWj0bMsWju-itd2s90Q4U,17402
+tilemap_parser/runtime/map_loader.py,sha256=jW-C9AdX8bknNEfB-rEY9g5oABvZDTosPJccvIgPf3Y,16278
+tilemap_parser/runtime/map_object.py,sha256=Sy3tt3OSfot1E2MaxrgfX4I8GlUA5bWPUEHwVJfjBgE,7551
+tilemap_parser/runtime/object_collision.py,sha256=FgxjTOtSHcjg1dlro9FPt4uAofvIiKXGTlYxT0Orh3U,18960
 tilemap_parser/runtime/particles.py,sha256=PO-1fwa-BW3FUPSECjvqH7s_4z5zocLzJZTze_1gUbY,18066
 tilemap_parser/runtime/renderer.py,sha256=vMO8Nfm6d7j6wlGGLxKrnQykdmnwRSExnIKpz9MZRUY,7132
 tilemap_parser/runtime/tile_collision.py,sha256=tPj9qKg9nbbOpKbAIYJh8QknjRg9oh-dyKdYvOD4QgA,77946
 tilemap_parser/utils/__init__.py,sha256=GjdWhC__OaDH-eZZkRxYnDzfd_5kTeHKcZ2_F1D3FEQ,621
 tilemap_parser/utils/geometry.py,sha256=UyZm1TMoUs40xnYmuxS8iD9626D6_Ad2SXa7l_ukg-c,22369
-tilemap_parser-4.2.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-tilemap_parser-4.2.0.dist-info/METADATA,sha256=FtcYuOKTkvql__PtSaEvvDkKgW4W8P_TcEH8wyYIbN0,44346
-tilemap_parser-4.2.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-tilemap_parser-4.2.0.dist-info/top_level.txt,sha256=VOScMmS9EE8Z6kFSJPMwiiFEqpnH2rjLF6cU8M_oFeU,15
-tilemap_parser-4.2.0.dist-info/RECORD,,
+tilemap_parser-4.2.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+tilemap_parser-4.2.2.dist-info/METADATA,sha256=uB7ZmHICQiitm9SjOWcB2Ux60HFcrbGuz_IH7D_nNBc,44346
+tilemap_parser-4.2.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+tilemap_parser-4.2.2.dist-info/top_level.txt,sha256=VOScMmS9EE8Z6kFSJPMwiiFEqpnH2rjLF6cU8M_oFeU,15
+tilemap_parser-4.2.2.dist-info/RECORD,,

{tilemap_parser-4.2.0.dist-info → tilemap_parser-4.2.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any