mima-engine 0.3.2__tar.gz → 0.3.3__tar.gz

{mima_engine-0.3.2 → mima_engine-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mima-engine
-Version: 0.3.2
+Version: 0.3.3
 Summary: A game engine based on pygame.
 Author-email: Stephan Balduin <stephan.balduin@mailbox.org>
 Classifier: License :: OSI Approved :: MIT License

{mima_engine-0.3.2 → mima_engine-0.3.3}/src/mima/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.3.2"
+__version__ = "0.3.3"
 
 from .core.engine import MimaEngine as MimaEngine
 from .core.mode_engine import MimaModeEngine as MimaModeEngine

{mima_engine-0.3.2 → mima_engine-0.3.3}/src/mima/advanced/shape.py

@@ -94,3 +94,6 @@ class ShapeCollection:
 
     def get_br_pos(self) -> Vector2:
         return self.pos + self.br
+
+    def get_bounding_size(self) -> Vector2:
+        return self.bounding_box.size

{mima_engine-0.3.2 → mima_engine-0.3.3}/src/mima/standalone/spatial.py

@@ -17,69 +17,67 @@ class SpatialGrid(Generic[T]):
         self._n_cols = int(math.ceil(world_size.x / cell_size))
         self._n_rows = int(math.ceil(world_size.y / cell_size))
 
-        # self._cells: dict[int, list[T]] = {
-        #     i: [] for i in range(self._n_cols * self._n_rows)
-        # }
         self._cells: list[list[T]] = [[] for _ in range(self._n_cols * self._n_rows)]
-        self._object_map: dict[T, int] = {}
+        self._object_map: dict[T, list[int]] = {}
         self.n_objects = 0
 
-    def insert(self, obj: T, pos: Vector2) -> None:
+    def insert(self, obj: T, pos: Vector2, size: Vector2 | None = None) -> None:
         """Insert object at given position in the grid."""
-        idx = self.get_grid_index(pos)
-        self._cells[idx].append(obj)
-        self._object_map[obj] = idx
+        size = Vector2(1, 1) if size is None else size
+        indices = cells_for_aabb(pos, size, self._cell_size, self._n_rows, self._n_cols)
+
+        for idx in indices:
+            self._cells[idx].append(obj)
+
+        self._object_map[obj] = indices
         self.n_objects += 1
 
-    def remove(self, obj: T, pos: Vector2) -> None:
-        """Remove object at given position from the grid."""
-        idx = self.get_grid_index(pos)
-        self._cells[idx].remove(obj)
+    def remove(self, obj: T) -> None:
+        """Remove object from all grid cells it occupies."""
+        indices = self._object_map.get(obj)
+        if indices is None:
+            return
+
+        for idx in indices:
+            if obj in self._cells[idx]:
+                self._cells[idx].remove(obj)
+
         self._object_map.pop(obj)
         self.n_objects -= 1
 
-    def relocate(self, obj: T, old_pos: Vector2, new_pos: Vector2) -> None:
-        """Move object from old position to new position in the grid."""
-        if old_pos == new_pos:
-            return
+    def relocate(self, obj: T, new_pos: Vector2, size: Vector2 | None = None) -> None:
+        """Move object to a new position in the grid."""
 
-        old_idx_from_pos = self.get_grid_index(old_pos)
-        if (old_idx := self._object_map[obj]) != old_idx_from_pos:
-            LOG.error(
-                "Cell mismatch for object %s: saved index %d != %d",
-                str(obj),
-                self._object_map[obj],
-                old_idx,
+        old_indices = self._object_map.get(obj)
+        if old_indices is None:
+            LOG.warning(
+                "Objects %s not in grid. Performing insertion instead.", str(obj)
             )
-        new_idx = self.get_grid_index(new_pos)
+            return self.insert(obj, new_pos, size)
 
-        if old_idx == new_idx:
+        size = Vector2(1, 1) if size is None else size
+
+        new_indices = cells_for_aabb(
+            new_pos, size, self._cell_size, self._n_rows, self._n_cols
+        )
+        if old_indices == new_indices:
             return
 
         LOG.debug(
-            "%s moving from (%.1f, %.1f) (cell %d) to (%.1f, %.1f) (cell %d)",
+            "Object %s (%s) moving from cells %s to %s",
             str(obj),
-            old_pos.x,
-            old_pos.y,
-            old_idx,
-            new_pos.x,
-            new_pos.y,
-            new_idx,
+            new_pos,
+            old_indices,
+            new_indices,
         )
+        for idx in old_indices:
+            if obj in self._cells[idx]:
+                self._cells[idx].remove(obj)
 
-        if old_idx < 0 or old_idx >= len(self._cells):
-            LOG.error(
-                "Old cell %d of object does not exist. Number of cells %d.",
-                old_idx,
-                len(self._cells),
-            )
+        for idx in new_indices:
+            self._cells[idx].append(obj)
 
-        if obj not in self._cells[old_idx]:
-            LOG.error("Object %s not in cell %d", str(obj), old_idx)
-
-        self._cells[old_idx].remove(obj)
-        self._cells[new_idx].append(obj)
-        self._object_map[obj] = new_idx
+        self._object_map[obj] = new_indices
 
     def get_grid_index(self, pos: Vector2) -> int:
         x, y = self.get_grid_coords(pos)
@@ -93,7 +91,7 @@ class SpatialGrid(Generic[T]):
 
     def get_all_objects(self) -> list[T]:
         """Return all objects stored in the grid."""
-        return [val for vals in self._cells for val in vals]
+        return list(self._object_map.keys())
 
     def get_objects_in_region(self, pos: Vector2, size: Vector2) -> list[T]:
         """Return all objects in the area defined by pos and size."""
@@ -105,15 +103,14 @@ class SpatialGrid(Generic[T]):
         ex = int(min(self._n_cols - 1, (pos.x + size.x - 1e-9) // self._cell_size))
         ey = int(min(self._n_rows - 1, (pos.y + size.y - 1e-9) // self._cell_size))
 
-        return list(
-            itertools.chain(
-                *[
-                    self._cells[gx + gy * self._n_cols]
-                    for gy in range(sy, ey + 1)  # include last index
-                    for gx in range(sx, ex + 1)
-                ]
-            )
-        )
+        result: set[T] = set()
+
+        for gy in range(sy, ey + 1):
+            row_offset = gy * self._n_cols
+            for gx in range(sx, ex + 1):
+                result.update(self._cells[gx + row_offset])
+
+        return list(result)
 
     def get_cells_in_region(
         self, pos: Vector2, size: Vector2
@@ -163,3 +160,28 @@ def clamp(val: float, low: float, high: float) -> float: ...
 
 def clamp(val: int | float, low: int | float, high: int | float) -> int | float:
     return max(low, min(high, val))
+
+
+def vmax(val: Vector2, other: Vector2) -> Vector2:
+    return Vector2(max(val.x, other.x), max(val.y, other.y))
+
+
+def vmin(val: Vector2, other: Vector2) -> Vector2:
+    return Vector2(min(val.x, other.x), min(val.y, other.y))
+
+
+def cells_for_aabb(
+    pos: Vector2, size: Vector2, cell_size: int, n_rows: int, n_cols: int
+) -> list[int]:
+    tl = pos // cell_size
+    br = (pos + size) // cell_size
+    v_cols = Vector2(n_cols - 1, n_rows - 1)
+    tl = vmax(Vector2(), vmin(tl, v_cols))
+    br = vmax(Vector2(), vmin(br, v_cols))
+
+    indices: list[int] = []
+    for y in range(int(tl.y), int(br.y) + 1):
+        for x in range(int(tl.x), int(br.x) + 1):
+            indices.append(x + y * n_cols)
+
+    return indices

mima_engine-0.3.3/tests/unit/test_spatial_grid.py

@@ -0,0 +1,211 @@
+import pytest
+from pygame import Vector2
+
+from mima.standalone.spatial import SpatialGrid
+
+
+@pytest.fixture
+def empty_grid() -> SpatialGrid[int]:
+    return SpatialGrid[int](Vector2(10, 10), 2)
+
+
+@pytest.fixture()
+def spatial_grid() -> SpatialGrid[int]:
+    grid = SpatialGrid[int](Vector2(10, 10), 2)
+    grid.insert(0, Vector2(3, 4), Vector2(0.2, 0.2))  # Cell 11
+    grid.insert(1, Vector2(1.5, 7), Vector2(0.2, 0.2))  # Cell 15
+    grid.insert(2, Vector2(8, 5), Vector2(0.2, 0.2))  # Cell 14
+    grid.insert(3, Vector2(2, 1), Vector2(0.2, 0.2))  # Cell 1
+    grid.insert(4, Vector2(2, 1), Vector2(0.2, 0.2))  # Cell 1
+    grid.insert(5, Vector2(2, 3), Vector2(0.2, 0.2))  # Cell 2
+    return grid
+
+
+@pytest.fixture()
+def large_object_grid() -> SpatialGrid[int]:
+    grid = SpatialGrid[int](Vector2(10, 10), 2)
+
+    grid.insert(0, Vector2(3, 4), Vector2(1, 1))  # cell 11
+    grid.insert(1, Vector2(0, 5), Vector2(4, 4))
+    grid.insert(2, Vector2(0, 9), Vector2(0.2, 0.2))
+    return grid
+
+
+@pytest.mark.parametrize(
+    "pos, expected_cell", [((1.5, 1), 0), ((2.5, 1), 1), ((20, 20), 24)]
+)
+def test_insert(
+    empty_grid: SpatialGrid[int], pos: tuple[int, int], expected_cell: int
+) -> None:
+    """Test insertion of objects.
+
+    Todo:
+        * Inserting out-of-bounds will add objects to border cells. Check if
+          this is the expected behavior for spatial grids.
+
+    """
+    empty_grid.insert(0, Vector2(pos))
+
+    assert empty_grid.n_objects == 1
+    assert 0 in empty_grid._cells[expected_cell]
+
+
+def test_insert_large_object(empty_grid: SpatialGrid[int]) -> None:
+    pos = Vector2(3, 3)
+    size = Vector2(4, 5.5)
+    indices = [6, 7, 8, 11, 12, 13, 16, 17, 18, 21, 22, 23]
+
+    empty_grid.insert(0, pos, size)
+
+    assert empty_grid.n_objects == 1
+    assert empty_grid._object_map[0] == indices
+    for idx in indices:
+        assert 0 in empty_grid._cells[idx]
+
+
+@pytest.mark.parametrize("obj, expected_cell", [(0, 11)])
+def test_remove(spatial_grid: SpatialGrid[int], obj: int, expected_cell: int) -> None:
+    """Test removal of objects."""
+
+    assert spatial_grid.n_objects == 6
+    assert len(spatial_grid._cells[expected_cell]) == 1
+    assert obj in spatial_grid._object_map
+
+    spatial_grid.remove(obj)
+
+    assert spatial_grid.n_objects == 5
+    assert len(spatial_grid._cells[expected_cell]) == 0
+    assert obj not in spatial_grid._object_map
+
+
+def test_remove_object_not_in_grid(spatial_grid: SpatialGrid[int]) -> None:
+    assert spatial_grid.n_objects == 6
+    assert 6 not in spatial_grid._object_map
+
+    spatial_grid.remove(6)
+
+    assert spatial_grid.n_objects == 6
+    assert 6 not in spatial_grid._object_map
+
+
+@pytest.mark.parametrize(
+    "obj,indices", [(0, [11, 12]), (1, [10, 11, 12, 15, 16, 17, 20, 21, 22]), (2, [20])]
+)
+def test_remove_large_object(
+    large_object_grid: SpatialGrid[int], obj: int, indices: list[int]
+) -> None:
+    for idx in indices:
+        assert obj in large_object_grid._cells[idx]
+    assert large_object_grid.n_objects == 3
+
+    large_object_grid.remove(obj)
+
+    for idx in indices:
+        assert obj not in large_object_grid._cells[idx]
+    assert large_object_grid.n_objects == 2
+
+
+def test_relocate(spatial_grid):
+    assert spatial_grid._object_map[3] == [1]
+    assert len(spatial_grid._cells[1]) == 2
+    assert 3 in spatial_grid._cells[1]
+    assert len(spatial_grid._cells[2]) == 0
+
+    spatial_grid.relocate(3, Vector2(4, 1), Vector2(0.2, 0.2))
+
+    assert spatial_grid._object_map[3] == [2]
+    assert len(spatial_grid._cells[1]) == 1
+    assert 3 not in spatial_grid._cells[1]
+    assert len(spatial_grid._cells[2]) == 1
+    assert 3 in spatial_grid._cells[2]
+
+
+@pytest.mark.parametrize("new_pos, expected_indices", [((4, 1), [2]), ((0, 0), [0])])
+def test_relocate_object_not_in_grid(
+    spatial_grid: SpatialGrid[int],
+    new_pos: tuple[int, int],
+    expected_indices: list[int],
+) -> None:
+    assert spatial_grid.n_objects == 6
+    assert 6 not in spatial_grid._object_map
+
+    spatial_grid.relocate(6, Vector2(new_pos), Vector2(0.2, 0.2))
+
+    assert spatial_grid.n_objects == 7
+    assert 6 in spatial_grid._object_map
+    assert spatial_grid._object_map[6] == expected_indices
+    assert 6 in spatial_grid._cells[expected_indices[0]]
+
+
+@pytest.mark.parametrize(
+    "obj,pos,size,old_indices, new_indices",
+    [
+        (0, (6, 2), (1, 1), [11, 12], [8]),
+        (
+            1,
+            (4, 4),
+            (4, 4),
+            [10, 11, 12, 15, 16, 17, 20, 21, 22],
+            [12, 13, 14, 17, 18, 19, 22, 23, 24],
+        ),
+    ],
+)
+def test_relocate_large_object(
+    large_object_grid: SpatialGrid[int],
+    obj: int,
+    pos: tuple[float, float],
+    size: tuple[float, float],
+    old_indices: list[int],
+    new_indices: list[int],
+) -> None:
+    for idx in old_indices:
+        assert obj in large_object_grid._cells[idx]
+    for idx in new_indices:
+        if idx not in old_indices:
+            assert obj not in large_object_grid._cells[idx]
+
+    large_object_grid.relocate(obj, Vector2(pos), Vector2(size))
+
+    for idx in old_indices:
+        if idx not in new_indices:
+            assert obj not in large_object_grid._cells[idx]
+    for idx in new_indices:
+        assert obj in large_object_grid._cells[idx]
+
+
+@pytest.mark.parametrize(
+    "pos, size, n_objects",
+    [((2.5, 2), (2, 3), 2), ((1.5, 0), (4, 4), 3), ((4, 5), (4, 4), 0)],
+)
+def test_get_objects_in_region(
+    spatial_grid: SpatialGrid[int],
+    pos: tuple[float, float],
+    size: tuple[float, float],
+    n_objects: int,
+) -> None:
+    objects = spatial_grid.get_objects_in_region(Vector2(pos), Vector2(size))
+
+    assert len(objects) == n_objects
+
+
+@pytest.mark.parametrize("pos, size, n_objects", [((0, 3), (4, 4), 2)])
+def test_get_large_objects_in_region(
+    large_object_grid,
+    pos: tuple[float, float],
+    size: tuple[float, float],
+    n_objects: int,
+) -> None:
+    objects = large_object_grid.get_objects_in_region(Vector2(pos), Vector2(size))
+
+    assert len(objects) == n_objects
+
+
+def print_grid(spatial_grid: SpatialGrid[int]) -> str:
+    s = ""
+    for y in range(spatial_grid._n_rows):
+        for x in range(spatial_grid._n_cols):
+            idx = x + y * spatial_grid._n_cols
+            s += f"{str(spatial_grid._cells[idx]):>7}"
+        s += "\n"
+    print(s)
+    return s