tilemap-parser 3.1.18__tar.gz → 3.1.20__tar.gz

{tilemap_parser-3.1.18 → tilemap_parser-3.1.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 3.1.18
+Version: 3.1.20
 Summary: Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime.
 Author: tilemap parser contributors
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -706,7 +706,7 @@ Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and co
 - **Map parsing**: Load and query tilemaps, layers, objects, and autotile data from JSON
 - **Animation**: Frame-based sprite animation with `AnimationPlayer`
 - **Collision (tile-based)**: Polygon collision detection for tilemaps with slide, platformer, and RPG movement modes via `CollisionRunner`
-- **Collision (object-to-object)**: Mixed-shape collision detection (rect, circle, capsule, polygon) with layer filtering via `ObjectCollisionManager`
+- **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
 

{tilemap_parser-3.1.18 → tilemap_parser-3.1.20}/README.md

@@ -7,7 +7,7 @@ Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and co
 - **Map parsing**: Load and query tilemaps, layers, objects, and autotile data from JSON
 - **Animation**: Frame-based sprite animation with `AnimationPlayer`
 - **Collision (tile-based)**: Polygon collision detection for tilemaps with slide, platformer, and RPG movement modes via `CollisionRunner`
-- **Collision (object-to-object)**: Mixed-shape collision detection (rect, circle, capsule, polygon) with layer filtering via `ObjectCollisionManager`
+- **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
 

{tilemap_parser-3.1.18 → tilemap_parser-3.1.20}/pyproject.toml

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

{tilemap_parser-3.1.18 → tilemap_parser-3.1.20}/src/tilemap_parser/runtime/object_collision.py

@@ -9,7 +9,8 @@ from __future__ import annotations
 
 import warnings
 from dataclasses import dataclass
-from typing import List, Optional, Protocol, Union
+from math import floor, isfinite
+from typing import Dict, Iterable, Iterator, List, Optional, Protocol, Set, Tuple, Union
 
 from ..parser.collision import (
     CapsuleShape,
@@ -310,16 +311,47 @@ class ObjectCollisionManager:
         - All-vs-all and one-vs-all queries
         - Layer filtering
 
-    Note: This version uses brute-force O(n²) detection.
-          Spatial partitioning is deferred to other version.
+    Uses a uniform-grid spatial broadphase and exact shape narrowphase.
+    The grid is rebuilt for each query so moved objects are always indexed
+    at their current world positions.
     """
 
-    def __init__(self) -> None:
+    def __init__(
+        self,
+        objects: Optional[Iterable[ICollidableObject]] = None,
+        *,
+        cell_size: float = 128.0,
+    ) -> None:
+        if not isfinite(cell_size) or cell_size <= 0:
+            raise ValueError("cell_size must be a finite positive number")
+
         self.objects: List[ICollidableObject] = []
+        self.cell_size = float(cell_size)
+        if objects is not None:
+            for obj in objects:
+                self.add_object(obj)
+
+    def __len__(self) -> int:
+        """Return the number of objects currently managed."""
+        return len(self.objects)
+
+    def __iter__(self) -> Iterator[ICollidableObject]:
+        """Iterate over managed objects in insertion order."""
+        return iter(self.objects)
+
+    def __contains__(self, obj: object) -> bool:
+        """Return True if the exact object instance is managed."""
+        return any(existing is obj for existing in self.objects)
+
+    def _find_object_index(self, obj: ICollidableObject) -> int:
+        for index, existing in enumerate(self.objects):
+            if existing is obj:
+                return index
+        return -1
 
     def add_object(self, obj: ICollidableObject) -> None:
         """Add an object to the collision system."""
-        if obj in self.objects:
+        if self._find_object_index(obj) != -1:
             warnings.warn(
                 f"Object {obj} is already in the collision manager, skipping.",
                 UserWarning,
@@ -330,27 +362,78 @@ class ObjectCollisionManager:
 
     def remove_object(self, obj: ICollidableObject) -> None:
         """Remove an object from the collision system."""
-        if obj not in self.objects:
+        index = self._find_object_index(obj)
+        if index == -1:
             warnings.warn(
                 f"Object {obj} is not in the collision manager, skipping.",
                 UserWarning,
                 stacklevel=2,
             )
             return
-        self.objects.remove(obj)
+        del self.objects[index]
+
+    def clear(self) -> None:
+        """Remove all objects from the collision system."""
+        self.objects.clear()
+
+    def _cells_for_aabb(
+        self,
+        aabb: tuple[float, float, float, float],
+    ) -> Iterator[Tuple[int, int]]:
+        left, top, right, bottom = aabb
+        min_cell_x = floor(left / self.cell_size)
+        max_cell_x = floor(right / self.cell_size)
+        min_cell_y = floor(top / self.cell_size)
+        max_cell_y = floor(bottom / self.cell_size)
+
+        for cell_y in range(min_cell_y, max_cell_y + 1):
+            for cell_x in range(min_cell_x, max_cell_x + 1):
+                yield (cell_x, cell_y)
+
+    def _object_aabb(
+        self,
+        obj: ICollidableObject,
+    ) -> tuple[float, float, float, float]:
+        return get_shape_aabb(obj.x, obj.y, obj.collision_shape)
+
+    def _build_spatial_index(
+        self,
+    ) -> tuple[Tuple[ICollidableObject, ...], Dict[Tuple[int, int], List[int]]]:
+        objects = tuple(self.objects)
+        grid: Dict[Tuple[int, int], List[int]] = {}
+
+        for index, obj in enumerate(objects):
+            for cell in self._cells_for_aabb(self._object_aabb(obj)):
+                grid.setdefault(cell, []).append(index)
+
+        return objects, grid
+
+    def _candidate_indices(
+        self,
+        obj: ICollidableObject,
+        grid: Dict[Tuple[int, int], List[int]],
+    ) -> Set[int]:
+        candidates: Set[int] = set()
+        for cell in self._cells_for_aabb(self._object_aabb(obj)):
+            candidates.update(grid.get(cell, ()))
+        return candidates
 
     def check_all_collisions(self) -> List[CollisionHit]:
         """
-        Check every unique pair (brute-force).
+        Check every potentially colliding pair.
 
         Returns a list of CollisionHit for all colliding pairs.
         Each pair appears at most once (i, j) with j > i.
         """
+        objects, grid = self._build_spatial_index()
         hits: List[CollisionHit] = []
-        n = len(self.objects)
-        for i in range(n):
-            for j in range(i + 1, n):
-                hit = check_collision(self.objects[i], self.objects[j])
+
+        for i, obj in enumerate(objects):
+            candidate_indices = self._candidate_indices(obj, grid)
+            for j in sorted(candidate_indices):
+                if j <= i:
+                    continue
+                hit = check_collision(objects[i], objects[j])
                 if hit is not None:
                     hits.append(hit)
         return hits
@@ -359,10 +442,13 @@ class ObjectCollisionManager:
         """
         Check one object against all others.
 
-        Skips comparison with itself.
+        The queried object does not need to be managed. If it is managed,
+        comparison with itself is skipped by identity.
         """
+        objects, grid = self._build_spatial_index()
         hits: List[CollisionHit] = []
-        for other in self.objects:
+        for index in sorted(self._candidate_indices(obj, grid)):
+            other = objects[index]
             if other is obj:
                 continue
             hit = check_collision(obj, other)

{tilemap_parser-3.1.18 → tilemap_parser-3.1.20}/src/tilemap_parser/runtime/tile_collision.py

@@ -960,6 +960,7 @@ class CollisionRunner:
                 sprite.y = lo
             elif sprite.vy < 0:
                 sprite.vy = 0.0
+                sprite.on_ground = False
                 result.hit_ceiling = True
             else:
                 sprite.on_ground = True

{tilemap_parser-3.1.18 → tilemap_parser-3.1.20}/src/tilemap_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 3.1.18
+Version: 3.1.20
 Summary: Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and collision detection runtime.
 Author: tilemap parser contributors
 License:                     GNU GENERAL PUBLIC LICENSE
@@ -706,7 +706,7 @@ Standalone parser/loader for tilemap-editor JSON maps, sprite animations, and co
 - **Map parsing**: Load and query tilemaps, layers, objects, and autotile data from JSON
 - **Animation**: Frame-based sprite animation with `AnimationPlayer`
 - **Collision (tile-based)**: Polygon collision detection for tilemaps with slide, platformer, and RPG movement modes via `CollisionRunner`
-- **Collision (object-to-object)**: Mixed-shape collision detection (rect, circle, capsule, polygon) with layer filtering via `ObjectCollisionManager`
+- **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
 

{tilemap_parser-3.1.18 → tilemap_parser-3.1.20}/tests/test_object_collision.py

@@ -21,6 +21,7 @@ from tilemap_parser.parser.collision import (
     CollisionPolygon,
     RectangleShape,
 )
+import tilemap_parser.runtime.object_collision as object_collision_runtime
 from tilemap_parser.runtime.object_collision import (
     CollisionHit,
     ObjectCollisionManager,
@@ -257,6 +258,22 @@ class TestManagerAddRemove:
             assert "already" in str(w[0].message).lower()
         assert len(mgr.objects) == 1
 
+    def test_add_value_equal_distinct_objects(self):
+        class EqualObject(_DummyObject):
+            def __eq__(self, other):
+                return isinstance(other, EqualObject)
+
+        mgr = ObjectCollisionManager()
+        a = EqualObject(0, 0)
+        b = EqualObject(20, 0)
+
+        mgr.add_object(a)
+        mgr.add_object(b)
+
+        assert len(mgr.objects) == 2
+        assert mgr.objects[0] is a
+        assert mgr.objects[1] is b
+
     def test_remove_nonexistent_warns(self):
         mgr = ObjectCollisionManager()
         obj = _make_rect(0, 0, 10, 10)
@@ -267,8 +284,49 @@ class TestManagerAddRemove:
             assert issubclass(w[0].category, UserWarning)
             assert "not" in str(w[0].message).lower()
 
+    def test_remove_uses_identity_not_equality(self):
+        class EqualObject(_DummyObject):
+            def __eq__(self, other):
+                return isinstance(other, EqualObject)
+
+        mgr = ObjectCollisionManager()
+        a = EqualObject(0, 0)
+        b = EqualObject(20, 0)
+        mgr.add_object(a)
+        mgr.add_object(b)
+
+        mgr.remove_object(b)
+
+        assert len(mgr.objects) == 1
+        assert mgr.objects[0] is a
+
+    def test_construct_with_objects(self):
+        a = _make_rect(0, 0, 10, 10)
+        b = _make_rect(20, 0, 10, 10)
+
+        mgr = ObjectCollisionManager([a, b])
+
+        assert len(mgr) == 2
+        objects = list(mgr)
+        assert objects[0] is a
+        assert objects[1] is b
+        assert a in mgr
+        assert b in mgr
+
+    def test_clear(self):
+        mgr = ObjectCollisionManager([_make_rect(0, 0, 10, 10)])
+
+        mgr.clear()
+
+        assert len(mgr) == 0
+        assert mgr.objects == []
+
 
 class TestManagerCheckAll:
+    def test_invalid_cell_size_raises(self):
+        with pytest.raises(ValueError, match="cell_size"):
+            ObjectCollisionManager(cell_size=0)
+
     def test_no_duplicates(self):
         """Three overlapping circles — should produce exactly 3 pairs."""
         mgr = ObjectCollisionManager()
@@ -286,6 +344,56 @@ class TestManagerCheckAll:
         mgr.add_object(_make_rect(0, 0, 10, 10))
         assert mgr.check_all_collisions() == []
 
+    def test_spatial_broadphase_skips_distant_pairs(self, monkeypatch):
+        mgr = ObjectCollisionManager(cell_size=16)
+        a = _make_rect(0, 0, 10, 10)
+        b = _make_rect(100, 0, 10, 10)
+        mgr.add_object(a)
+        mgr.add_object(b)
+        calls = []
+
+        def fake_check_collision(obj_a, obj_b):
+            calls.append((obj_a, obj_b))
+            return None
+
+        monkeypatch.setattr(
+            object_collision_runtime,
+            "check_collision",
+            fake_check_collision,
+        )
+
+        assert mgr.check_all_collisions() == []
+        assert calls == []
+
+    def test_large_object_spanning_cells_collides(self):
+        mgr = ObjectCollisionManager(cell_size=16)
+        large = _make_rect(0, 0, 64, 16)
+        small = _make_rect(48, 0, 8, 8)
+        mgr.add_object(large)
+        mgr.add_object(small)
+
+        hits = mgr.check_all_collisions()
+
+        assert len(hits) == 1
+        assert hits[0].object_a is large
+        assert hits[0].object_b is small
+
+    def test_moved_objects_are_reindexed_per_query(self):
+        mgr = ObjectCollisionManager(cell_size=16)
+        a = _make_rect(0, 0, 10, 10)
+        b = _make_rect(100, 0, 10, 10)
+        mgr.add_object(a)
+        mgr.add_object(b)
+
+        assert mgr.check_all_collisions() == []
+
+        b.x = 8
+        hits = mgr.check_all_collisions()
+
+        assert len(hits) == 1
+        assert hits[0].involves(a)
+        assert hits[0].involves(b)
+
 
 class TestManagerCheckObject:
     def test_returns_hits(self):
@@ -316,6 +424,20 @@ class TestManagerCheckObject:
         hits = mgr.check_object(a)
         assert hits == []
 
+    def test_unmanaged_query_object(self):
+        mgr = ObjectCollisionManager(cell_size=16)
+        query = _make_rect(0, 0, 10, 10)
+        managed = _make_rect(8, 0, 10, 10)
+        far = _make_rect(100, 0, 10, 10)
+        mgr.add_object(managed)
+        mgr.add_object(far)
+
+        hits = mgr.check_object(query)
+
+        assert len(hits) == 1
+        assert hits[0].object_a is query
+        assert hits[0].object_b is managed
+
 
 # ---------------------------------------------------------------------------
 # CollisionHit helpers