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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tilemap-parser
-Version: 3.1.20
+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

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

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

@@ -455,3 +455,23 @@ class ObjectCollisionManager:
             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.20 → 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.20
+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

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

@@ -8,32 +8,33 @@ 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,
     CollisionPolygon,
     RectangleShape,
 )
-import tilemap_parser.runtime.object_collision as object_collision_runtime
 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."""
 
@@ -68,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)
@@ -94,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
 
 
@@ -101,6 +104,7 @@ class TestShouldCollide:
 # check_collision
 # ---------------------------------------------------------------------------
 
+
 class TestCheckCollisionCircleCircle:
     def test_colliding(self):
         a = _make_circle(0, 0, 10)
@@ -237,6 +241,7 @@ class TestCheckCollisionPolygon:
 # ObjectCollisionManager
 # ---------------------------------------------------------------------------
 
+
 class TestManagerAddRemove:
     def test_add_and_remove(self):
         mgr = ObjectCollisionManager()
@@ -439,10 +444,44 @@ class TestManagerCheckObject:
         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)
@@ -486,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
@@ -496,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
@@ -506,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
@@ -516,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
@@ -526,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
@@ -536,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
@@ -552,6 +604,7 @@ class TestCollisionHitHelpers:
 # Capsule collision
 # ---------------------------------------------------------------------------
 
+
 def _make_capsule(
     x: float = 0.0,
     y: float = 0.0,
@@ -563,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.20 → 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
 
 
 # ===========================================================================