tilemap-parser 3.1.19__tar.gz → 3.1.21__tar.gz

{tilemap_parser-3.1.19 → tilemap_parser-3.1.21}/PKG-INFO

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tilemap-parser"
-version = "3.1.19"
+version = "3.1.21"
 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.19 → tilemap_parser-3.1.21}/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,13 +442,36 @@ 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)
             if hit is not None:
                 hits.append(hit)
         return hits
+
+    def check_object_first(self, obj: ICollidableObject) -> Optional[CollisionHit]:
+        """
+        Check one object against all others and return the first collision hit.
+
+        The queried object does not need to be managed. If it is managed,
+        comparison with itself is skipped by identity.
+
+        Candidate iteration follows insertion order among the spatially relevant
+        managed objects.
+        """
+        objects, grid = self._build_spatial_index()
+        for index in sorted(self._candidate_indices(obj, grid)):
+            other = objects[index]
+            if other is obj:
+                continue
+            hit = check_collision(obj, other)
+            if hit is not None:
+                return hit
+        return None

{tilemap_parser-3.1.19 → tilemap_parser-3.1.21}/src/tilemap_parser.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 3.1.19
+Version: 3.1.21
 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.19 → tilemap_parser-3.1.21}/tests/test_object_collision.py

@@ -8,13 +8,15 @@ Covers:
 - ObjectCollisionManager (add/remove, queries, duplicates, warnings)
 """
 
+import sys
 import warnings
-import pytest
 from pathlib import Path
-import sys
+
+import pytest
 
 sys.path.insert(0, str(Path(__file__).parent.parent / "src"))
 
+import tilemap_parser.runtime.object_collision as object_collision_runtime
 from tilemap_parser.parser.collision import (
     CapsuleShape,
     CircleShape,
@@ -24,15 +26,15 @@ from tilemap_parser.parser.collision import (
 from tilemap_parser.runtime.object_collision import (
     CollisionHit,
     ObjectCollisionManager,
-    should_collide,
     check_collision,
+    should_collide,
 )
 
-
 # ---------------------------------------------------------------------------
 # Helpers — concrete objects implementing ICollidableObject
 # ---------------------------------------------------------------------------
 
+
 class _DummyObject:
     """Minimal collidable object for tests."""
 
@@ -67,6 +69,7 @@ def _make_poly(x, y, vertices, collision_layer=1, collision_mask=0xFFFFFFFF):
 # should_collide
 # ---------------------------------------------------------------------------
 
+
 class TestShouldCollide:
     def test_default_layers_collide(self):
         a = _make_rect(0, 0, 10, 10)
@@ -93,6 +96,7 @@ class TestShouldCollide:
             x = 0.0
             y = 0.0
             collision_shape = RectangleShape(width=10, height=10)
+
         assert should_collide(BareObject(), BareObject()) is True
 
 
@@ -100,6 +104,7 @@ class TestShouldCollide:
 # check_collision
 # ---------------------------------------------------------------------------
 
+
 class TestCheckCollisionCircleCircle:
     def test_colliding(self):
         a = _make_circle(0, 0, 10)
@@ -236,6 +241,7 @@ class TestCheckCollisionPolygon:
 # ObjectCollisionManager
 # ---------------------------------------------------------------------------
 
+
 class TestManagerAddRemove:
     def test_add_and_remove(self):
         mgr = ObjectCollisionManager()
@@ -257,6 +263,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 +289,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 +349,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,11 +429,59 @@ 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
+
+
+class TestManagerCheckObjectFirst:
+    def test_returns_first_hit(self):
+        mgr = ObjectCollisionManager()
+        query = _make_circle(0, 0, 10)
+        first = _make_circle(15, 0, 10)
+        second = _make_circle(18, 0, 10)
+        far = _make_circle(100, 0, 10)
+        mgr.add_object(first)
+        mgr.add_object(second)
+        mgr.add_object(far)
+
+        hit = mgr.check_object_first(query)
+
+        assert hit is not None
+        assert hit.object_a is query
+        assert hit.object_b is first
+
+    def test_returns_none_when_no_hit(self):
+        mgr = ObjectCollisionManager()
+        query = _make_rect(0, 0, 10, 10)
+        far = _make_rect(100, 0, 10, 10)
+        mgr.add_object(far)
+
+        assert mgr.check_object_first(query) is None
+
+    def test_skips_self(self):
+        mgr = ObjectCollisionManager()
+        obj = _make_rect(0, 0, 10, 10)
+        mgr.add_object(obj)
+
+        assert mgr.check_object_first(obj) is None
+
 
 # ---------------------------------------------------------------------------
 # CollisionHit helpers
 # ---------------------------------------------------------------------------
 
+
 class TestCollisionHitHelpers:
     def test_resolve_separates(self):
         a = _make_circle(0, 0, 10)
@@ -364,8 +525,10 @@ class TestCollisionHitHelpers:
     def test_slide_head_on(self):
         """Directly into surface → zero tangential motion."""
         hit = CollisionHit(
-            object_a=None, object_b=None,
-            normal=(1.0, 0.0), depth=5.0,
+            object_a=None,
+            object_b=None,
+            normal=(1.0, 0.0),
+            depth=5.0,
         )
         sx, sy = hit.slide_velocity(10.0, 0.0)
         assert sx == 0.0
@@ -374,8 +537,10 @@ class TestCollisionHitHelpers:
     def test_slide_angled(self):
         """Diagonal into surface → only perpendicular component removed."""
         hit = CollisionHit(
-            object_a=None, object_b=None,
-            normal=(1.0, 0.0), depth=5.0,
+            object_a=None,
+            object_b=None,
+            normal=(1.0, 0.0),
+            depth=5.0,
         )
         sx, sy = hit.slide_velocity(10.0, 5.0)
         assert sx == 0.0  # x component fully removed
@@ -384,8 +549,10 @@ class TestCollisionHitHelpers:
     def test_slide_parallel(self):
         """Velocity along the surface → unchanged."""
         hit = CollisionHit(
-            object_a=None, object_b=None,
-            normal=(0.0, 1.0), depth=5.0,
+            object_a=None,
+            object_b=None,
+            normal=(0.0, 1.0),
+            depth=5.0,
         )
         sx, sy = hit.slide_velocity(10.0, 0.0)
         assert sx == 10.0
@@ -394,8 +561,10 @@ class TestCollisionHitHelpers:
     def test_slide_away(self):
         """Velocity pointing away from surface → unchanged."""
         hit = CollisionHit(
-            object_a=None, object_b=None,
-            normal=(1.0, 0.0), depth=5.0,
+            object_a=None,
+            object_b=None,
+            normal=(1.0, 0.0),
+            depth=5.0,
         )
         sx, sy = hit.slide_velocity(-10.0, 0.0)
         assert sx == -10.0
@@ -404,8 +573,10 @@ class TestCollisionHitHelpers:
     def test_slide_zero(self):
         """Zero velocity → zero."""
         hit = CollisionHit(
-            object_a=None, object_b=None,
-            normal=(1.0, 0.0), depth=5.0,
+            object_a=None,
+            object_b=None,
+            normal=(1.0, 0.0),
+            depth=5.0,
         )
         sx, sy = hit.slide_velocity(0.0, 0.0)
         assert sx == 0.0
@@ -414,10 +585,13 @@ class TestCollisionHitHelpers:
     def test_slide_diagonal_normal(self):
         """Normal at 45°, velocity into surface → slide along surface."""
         import math
+
         n = (1.0 / math.sqrt(2), 1.0 / math.sqrt(2))
         hit = CollisionHit(
-            object_a=None, object_b=None,
-            normal=n, depth=5.0,
+            object_a=None,
+            object_b=None,
+            normal=n,
+            depth=5.0,
         )
         sx, sy = hit.slide_velocity(1.0, 0.0)
         # Dot = 1/sqrt(2) ≈ 0.707
@@ -430,6 +604,7 @@ class TestCollisionHitHelpers:
 # Capsule collision
 # ---------------------------------------------------------------------------
 
+
 def _make_capsule(
     x: float = 0.0,
     y: float = 0.0,
@@ -441,7 +616,8 @@ def _make_capsule(
     collision_mask: int = 0xFFFFFFFF,
 ) -> _DummyObject:
     return _DummyObject(
-        x=x, y=y,
+        x=x,
+        y=y,
         shape=CapsuleShape(radius=radius, height=height, offset=(ox, oy)),
         collision_layer=collision_layer,
         collision_mask=collision_mask,

{tilemap_parser-3.1.19 → tilemap_parser-3.1.21}/tests/test_tile_collision.py

@@ -142,9 +142,9 @@ class TestShapeBounds:
         sprite = MockSprite(x=100, y=200, shape=CapsuleShape(radius=8, height=48, offset=(0, 0)))
         left, top, right, bottom = get_shape_bounds(sprite)
         assert left == 92
-        assert top == 200
+        assert top == 192
         assert right == 108
-        assert bottom == 264
+        assert bottom == 256
 
 
 # ===========================================================================