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

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: mima-engine
-Version: 0.3.2
+Version: 0.3.4
 Summary: A game engine based on pygame.
 Author-email: Stephan Balduin <stephan.balduin@mailbox.org>
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Requires-Python: >=3.12
+Requires-Python: >=3.10
 Provides-Extra: ce
 Requires-Dist: pygame-ce; extra == 'ce'
 Provides-Extra: dev

{mima_engine-0.3.2 → mima_engine-0.3.4}/pyproject.toml

@@ -11,7 +11,7 @@ authors = [
 ]
 description = "A game engine based on pygame."
 readme = "README.md"
-requires-python = ">=3.12"
+requires-python = ">=3.10"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",

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

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

{mima_engine-0.3.2 → mima_engine-0.3.4}/src/mima/advanced/assets.py

@@ -1,7 +1,8 @@
 import csv
 import logging
 from pathlib import Path
-from typing import Any, TypeAlias
+
+from typing_extensions import TypeAlias
 
 from mima.standalone.tiled_map import MapManager
 

{mima_engine-0.3.2 → mima_engine-0.3.4}/src/mima/advanced/scene.py

@@ -2,9 +2,9 @@ from __future__ import annotations
 
 import logging
 from enum import Enum
-from typing import Any, Generic, TypeVar
 
 import pygame
+from typing_extensions import Any, Generic, TypeVar
 
 from mima.standalone.transformed_view import TileTransformedView
 
@@ -296,9 +296,14 @@ class Scene(Generic[V]):
         return success
 
     def draw(self) -> None:
+        return
+
+    def _draw(self) -> None:
         for window in self._windows.values():
             window.draw()
 
+        self.draw()
+
     def set_manager(self, manager: SceneManager) -> None:
         self._manager = manager
 
@@ -384,7 +389,7 @@ class SceneManager(Generic[S, V]):
         if self._scene is None:
             return
 
-        self._scene.draw()
+        self._scene._draw()
 
 
 def position_to_screen_rect(

{mima_engine-0.3.2 → mima_engine-0.3.4}/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.4}/src/mima/advanced/shaped_sprite.py

@@ -1,6 +1,5 @@
-from typing import Any, Generic
-
 from pygame import Vector2
+from typing_extensions import Any, Generic
 
 from mima.advanced.shape import ShapeCollection
 from mima.standalone.geometry import shape_from_dict

{mima_engine-0.3.2 → mima_engine-0.3.4}/src/mima/standalone/camera.py

@@ -1,7 +1,7 @@
 from enum import Enum
-from typing import Generic, Protocol, TypeVar
 
 from pygame import Vector2
+from typing_extensions import Generic, Protocol, TypeVar
 
 
 class CameraTarget(Protocol):

{mima_engine-0.3.2 → mima_engine-0.3.4}/src/mima/standalone/geometry.py

@@ -1,8 +1,8 @@
 # noqa: E741
 import math
-from typing import Any, TypeAlias, overload
 
 from pygame.math import Vector2
+from typing_extensions import Any, TypeAlias, overload
 
 EPSILON = 1e-3
 

{mima_engine-0.3.2 → mima_engine-0.3.4}/src/mima/standalone/pixel_font.py

@@ -1,6 +1,5 @@
-from typing import Protocol
-
 from pygame import BLEND_RGBA_MIN, Surface, Vector2
+from typing_extensions import Protocol
 
 TRANSPARENT_COLOR = (254, 252, 253)
 

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

@@ -1,9 +1,8 @@
-import itertools
 import logging
 import math
-from typing import Generic, TypeVar, overload
 
 from pygame import Vector2
+from typing_extensions import Generic, TypeVar, overload
 
 LOG = logging.getLogger(__name__)
 T = TypeVar("T")
@@ -17,69 +16,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 +90,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 +102,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 +159,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.2 → mima_engine-0.3.4}/src/mima/standalone/sprite.py

@@ -1,9 +1,7 @@
-from collections import defaultdict
 from enum import Enum
-from typing import Any, Generic, Protocol, TypeVar
 
-import pygame
 from pygame import Surface, Vector2
+from typing_extensions import Any, Generic, Protocol, TypeVar
 
 GS = TypeVar("GS", bound=Enum)
 D = TypeVar("D", bound=Enum)

{mima_engine-0.3.2 → mima_engine-0.3.4}/src/mima/standalone/tiled_map.py

@@ -6,12 +6,12 @@ import math
 from dataclasses import dataclass
 from io import StringIO
 from pathlib import Path
-from typing import Any, Protocol, Self, TypeAlias, overload
 from xml.etree import ElementTree
 from xml.etree.ElementTree import Element
 
 import pygame
 from pygame import Surface, Vector2
+from typing_extensions import Any, Protocol, Self, TypeAlias, overload
 
 LOG = logging.getLogger(__name__)
 
@@ -299,7 +299,8 @@ class TiledObject(_TiledBase):
             self.pos.y -= self.size.y
         else:
             self.size = Vector2(
-                float(o_xtree.attrib["width"]), float(o_xtree.attrib.get("height", 0.0))
+                float(o_xtree.attrib.get("width", 0.0)),
+                float(o_xtree.attrib.get("height", 0.0)),
             )
 
         self.name = o_xtree.attrib.get("name", self.name)

{mima_engine-0.3.2 → mima_engine-0.3.4}/src/mima/standalone/transformed_view.py

@@ -1,9 +1,10 @@
 import logging
 import math
-from typing import TypeAlias, Union
 
 import pygame
-from pygame import Event, Surface, Vector2
+from pygame import Surface, Vector2
+from pygame.event import Event
+from typing_extensions import TypeAlias, Union
 
 LOG = logging.getLogger(__name__)
 Color: TypeAlias = Union[tuple[int, int, int], tuple[int, int, int, int]]
@@ -197,7 +198,7 @@ class TransformedView:
         self, pos: Vector2, color: tuple[int, int, int] | tuple[int, int, int, int]
     ) -> None:
         pos = self.world_to_screen(pos)
-        self._screen.set_at(pos, color)
+        self._screen.set_at((int(pos.x), int(pos.y)), color)
 
     def draw_line(
         self, pos1: Vector2, pos2: Vector2, color: Color | None = None, width: int = 1

{mima_engine-0.3.2 → mima_engine-0.3.4}/src/mima/standalone/user_input.py

@@ -1,8 +1,8 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Protocol, TypeVar
 
 import pygame
+from typing_extensions import Protocol, TypeVar
 
 
 class Input(Enum):

{mima_engine-0.3.2 → mima_engine-0.3.4}/tests/system/test_window_manager.py

@@ -23,7 +23,6 @@ GAME_VIEW = 1
 MENU_VIEW = 2
 
 
-
 class TitleView(View[int]):
     def __init__(self) -> None:
         super().__init__(TITLE_VIEW, screen)
@@ -65,6 +64,40 @@ class TitleView(View[int]):
     def draw(self) -> None:
         self.ttv.fill_rect(self._pos, self._size, (246, 204, 64))
 
+        self.ttv.draw_surface(
+            pygame.Vector2(16, 32), my_font.render("TITLE VIEW", False, (0, 0, 0))
+        )
+
+        self.ttv.draw_surface(
+            pygame.Vector2(16, 64), my_font.render("d: Next Scene", False, (0, 0, 0))
+        )
+
+        self.ttv.draw_surface(
+            pygame.Vector2(16, 96),
+            my_font.render(
+                "f: Next Scene (Top / Bottom Split Screen)", False, (0, 0, 0)
+            ),
+        )
+
+        self.ttv.draw_surface(
+            pygame.Vector2(16, 128),
+            my_font.render(
+                "c: Next Scene (Left / Right Split Screen)", False, (0, 0, 0)
+            ),
+        )
+
+        self.ttv.draw_surface(
+            pygame.Vector2(16, 160),
+            my_font.render("x: Next Scene (4-player Split Screen)", False, (0, 0, 0)),
+        )
+
+        self.ttv.draw_surface(
+            pygame.Vector2(16, 192),
+            my_font.render(
+                "a: Return to this scene (on any Next Scene)", False, (0, 0, 0)
+            ),
+        )
+
 
 class GameView(View[int]):
     def __init__(self) -> None:
@@ -104,10 +137,25 @@ class GameView(View[int]):
         self.ttv.fill_rect(pygame.Vector2(0, 0), self._size, color)
 
         self.ttv.draw_surface(
-            pygame.Vector2(10, 10),
-            my_font.render(f"{self._position.name}", False, (255, 255, 255)),
+            pygame.Vector2(16, 32),
+            my_font.render(f"GAME VIEW {self._position.name}", False, (255, 255, 255)),
         )
 
+        if self._position in [
+            Position.FULL,
+            Position.TOP,
+            Position.LEFT,
+            Position.TOP_LEFT,
+        ]:
+            self.ttv.draw_surface(
+                pygame.Vector2(16, 64),
+                my_font.render("s: Go to Menu View", False, (255, 255, 255)),
+            )
+            self.ttv.draw_surface(
+                pygame.Vector2(16, 96),
+                my_font.render("a: Back to Title Scene", False, (255, 255, 255)),
+            )
+
 
 class MenuView(View[int]):
     def __init__(self) -> None:
@@ -137,12 +185,26 @@ class MenuView(View[int]):
     def draw(self) -> None:
         self.ttv.fill_rect(pygame.Vector2(0, 0), self._size, (0, 144, 54))
 
-        txt = f"{self._position.name}"
-
         self.ttv.draw_surface(
-            pygame.Vector2(10, 10), my_font.render(txt, False, (255, 255, 255))
+            pygame.Vector2(16, 32),
+            my_font.render(f"MENU VIEW {self._position.name}", False, (255, 255, 255)),
         )
 
+        if self._position in [
+            Position.FULL,
+            Position.TOP,
+            Position.LEFT,
+            Position.TOP_LEFT,
+        ]:
+            self.ttv.draw_surface(
+                pygame.Vector2(16, 64),
+                my_font.render("w: Go to Game View", False, (255, 255, 255)),
+            )
+            self.ttv.draw_surface(
+                pygame.Vector2(16, 96),
+                my_font.render("a: Back to Title Scene", False, (255, 255, 255)),
+            )
+
 
 class TitleScene(Scene):
     def enter_focus(self, data: dict[str, Any]) -> None:
@@ -155,6 +217,11 @@ class TitleScene(Scene):
         self._windows.clear()
         return {}
 
+    def draw(self) -> None:
+        screen.blit(
+            my_font.render("TITLE SCENE", False, (0, 0, 0)), pygame.Vector2(900, 8)
+        )
+
 
 class GameScene(Scene):
     def __init__(self):
@@ -173,6 +240,12 @@ class GameScene(Scene):
         self._windows.clear()
         return {}
 
+    def draw(self) -> None:
+        screen.blit(
+            my_font.render(" GAME SCENE", False, (255, 255, 255)),
+            pygame.Vector2(900, 8),
+        )
+
 
 sm = SceneManager[int, int]()
 sm.add_scene(TitleScene(), TITLE_SCENE)