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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mima-engine
-Version: 0.3.0
+Version: 0.3.2
 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.0 → mima_engine-0.3.2}/src/mima/__init__.py

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

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

@@ -1224,49 +1224,90 @@ def _circle_collides_with_line(
 def _circle_collides_with_rect(
     c: Circle, r: Rect, move_both: bool = False
 ) -> tuple[Vector2, Vector2]:
-    closest_point = closest(r, c)
-    ray = closest_point - c.pos
-    overlap = c.radius - ray.magnitude()
-    # TODO: std::isnan(overlap): overlap=0
     new_pos1 = Vector2(c.pos.x, c.pos.y)
     new_pos2 = Vector2(r.pos.x, r.pos.y)
-    try:
-        ray.normalize()
-    except ValueError:
-        # breakpoint()
-        overlap = 0
 
-    if overlap > 0:
-        if move_both:
-            new_pos1 -= ray.normalize() * overlap * 0.5
-            new_pos2 += ray.normalize() * overlap * 0.5
+    closest_point = closest(r, c)
+    # ray = closest_point - c.pos
+    # overlap = c.radius - ray.magnitude()
+    # TODO: std::isnan(overlap): overlap=0
+    # try:
+    #     ray.normalize()
+    # except ValueError:
+    #     # breakpoint()
+    #     overlap = 0
+
+    # if overlap > 0:
+    #     if move_both:
+    #         new_pos1 -= ray.normalize() * overlap * 0.5
+    #         new_pos2 += ray.normalize() * overlap * 0.5
+    #     else:
+    #         new_pos1 -= ray.normalize() * overlap
+
+    delta = c.pos - closest_point
+    dist_sq = delta.length_squared()
+    if dist_sq == 0:
+        dx = min(abs(c.pos.x - r.left().pos.x), abs(c.pos.x - r.right().pos.x))
+        dy = min(abs(c.pos.y - r.top().pos.y), abs(c.pos.y - r.bottom().pos.y))
+        if dx < dy:
+            normal = Vector2(1, 0) if c.pos.x > r.middle().x else Vector2(-1, 0)
         else:
-            new_pos1 -= ray.normalize() * overlap
+            normal = Vector2(0, 1) if c.pos.y > r.middle().y else Vector2(0, -1)
+        distance = 0
+    else:
+        distance = math.sqrt(dist_sq)
+        normal = delta / distance
 
+    penetration = c.radius - distance
+    if move_both:
+        new_pos1 += normal * penetration * 0.5
+        new_pos2 -= normal * penetration * 0.5
+    else:
+        new_pos1 += normal * penetration
     return new_pos1, new_pos2
 
 
 def _circle_collides_with_circle(
     c1: Circle, c2: Circle, move_both: bool = False
 ) -> tuple[Vector2, Vector2]:
-    distance = (c1.pos - c2.pos).magnitude()
-    overlap = distance - c1.radius - c2.radius
-
     new_pos1 = Vector2(c1.pos.x, c1.pos.y)
     new_pos2 = Vector2(c2.pos.x, c2.pos.y)
-    offset = c1.pos - c2.pos
 
-    if distance == 0:
-        offset = Vector2(overlap, overlap)
+    # distance = (c1.pos - c2.pos).magnitude()
+    # overlap = distance - c1.radius - c2.radius
+
+    # offset = c1.pos - c2.pos
+
+    # if distance == 0:
+    #     offset = Vector2(overlap, overlap)
+    # else:
+    #     offset *= overlap / distance
+
+    # if move_both:
+    #     new_pos1 -= offset * 0.5
+    #     new_pos2 += offset * 0.5
+    # else:
+    #     new_pos1 -= offset
+    delta = c1.pos - c2.pos
+    dist_sq = delta.length_squared()
+
+    if dist_sq == 0:
+        # Deterministic fallback
+        normal = Vector2(1, 0) if id(c1) < id(c2) else Vector2(-1, 0)
+        distance = 0
     else:
-        offset *= overlap / distance
+        distance = math.sqrt(dist_sq)
+        normal = delta / distance
+
+    penetration = c1.radius + c2.radius - distance
+    if penetration <= 0:
+        return new_pos1, new_pos2
 
     if move_both:
-        new_pos1 -= offset * 0.5
-        new_pos2 += offset * 0.5
-    else:
-        new_pos1 -= offset
-    return new_pos1, new_pos2
+        correction = normal * (penetration * 0.5)
+        return new_pos1 + correction, new_pos2 - correction
+
+    return new_pos1 + normal * penetration, new_pos2
 
 
 def vmax(val: Vector2, other: Vector2) -> Vector2:

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

@@ -21,18 +21,21 @@ class SpatialGrid(Generic[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.n_objects = 0
 
     def insert(self, obj: T, pos: Vector2) -> 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
         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)
+        self._object_map.pop(obj)
         self.n_objects -= 1
 
     def relocate(self, obj: T, old_pos: Vector2, new_pos: Vector2) -> None:
@@ -40,17 +43,22 @@ class SpatialGrid(Generic[T]):
         if old_pos == new_pos:
             return
 
-        old_idx = self.get_grid_index(old_pos)
+        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,
+            )
         new_idx = self.get_grid_index(new_pos)
 
         if old_idx == new_idx:
             return
 
-        self._cells[old_idx].remove(obj)
-        self._cells[new_idx].append(obj)
-
         LOG.debug(
-            "Object moving from (%.1f, %.1f) (cell %d) to (%.1f, %.1f) (cell %d)",
+            "%s moving from (%.1f, %.1f) (cell %d) to (%.1f, %.1f) (cell %d)",
+            str(obj),
             old_pos.x,
             old_pos.y,
             old_idx,
@@ -59,6 +67,20 @@ class SpatialGrid(Generic[T]):
             new_idx,
         )
 
+        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),
+            )
+
+        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
+
     def get_grid_index(self, pos: Vector2) -> int:
         x, y = self.get_grid_coords(pos)
         return x + y * self._n_cols
@@ -118,6 +140,7 @@ class SpatialGrid(Generic[T]):
 
     def clear(self) -> None:
         self._cells: list[list[T]] = [[] for _ in range(self._n_cols * self._n_rows)]
+        self._object_map = {}
         self.n_objects = 0
 
 

{mima_engine-0.3.0 → mima_engine-0.3.2}/src/mima/standalone/sprite.py

@@ -19,6 +19,7 @@ class Renderer(Protocol):
         src_size: Vector2 | None = None,
         scale: float = 1.0,
         angle: float = 0,
+        cache: bool = False,
         special_flags: int = 0,
     ) -> None: ...
 
@@ -94,7 +95,7 @@ class AnimatedSprite(Generic[GS, D]):
 
         return update_vals
 
-    def draw(self, pos: Vector2, ttv: Renderer) -> None:
+    def draw(self, pos: Vector2, ttv: Renderer, cache: bool = False) -> None:
         if self._image is None:
             return
 
@@ -104,6 +105,7 @@ class AnimatedSprite(Generic[GS, D]):
             src_pos=self._src_pos,
             src_size=self._src_size,
             scale=self._scale,
+            cache=cache,
         )
 
     def reset(self) -> None:

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

@@ -82,6 +82,7 @@ class Renderer(Protocol):
         src_size: Vector2 | None = None,
         scale: float = 1.0,
         angle: float = 0,
+        cache: bool = False,
         special_flags: int = 0,
     ) -> None: ...
 
@@ -426,8 +427,8 @@ class TiledLayerRenderable:
         self.duration: float = 1.0
         self.pos: Vector2 = Vector2()
 
-    def draw(self, ttv: Renderer) -> None:
-        ttv.draw_surface(self.pos, self.image)
+    def draw(self, ttv: Renderer, cache: bool = False) -> None:
+        ttv.draw_surface(self.pos, self.image, cache=cache)
 
     def get_pos(self) -> Vector2:
         return self.pos
@@ -770,6 +771,19 @@ class TiledTilemap:
                     tiles.append(tile)
         return tiles
 
+    def get_tiles_in_area(
+        self, pos: Vector2, area: Vector2, z: int = 0
+    ) -> list[TiledTile]:
+        tiles = []
+        tl = vfloor(pos)
+        br = tl + vfloor(area.elementwise() + 1)
+
+        for y in range(int(tl.y), int(br.y)):
+            for x in range(int(tl.x), int(br.x)):
+                tiles.extend(self.get_tiles(x, y, z))
+
+        return tiles
+
     def _collect_tile(self, layer: _TiledLayer, x: int, y: int) -> TiledTile | None:
         tid = layer.get_index(x, y)
         if tid <= 0:

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

@@ -208,8 +208,10 @@ class TransformedView:
         pygame.draw.line(
             surface=self._screen,
             color=color,
-            start_pos=self.world_to_screen(pos1) + self._pos,
-            end_pos=self.world_to_screen(pos2) + self._pos,
+            start_pos=(self.world_to_screen(pos1) + self._pos).elementwise()
+            * self._pixel_scale,
+            end_pos=(self.world_to_screen(pos2) + self._pos).elementwise()
+            * self._pixel_scale,
             width=width,
         )
 
@@ -327,6 +329,7 @@ class TransformedView:
         src_size: Vector2 | None = None,
         scale: float = 1.0,
         angle: float = 0,
+        cache: bool = False,
         special_flags: int = 0,
     ) -> None:
         src_size = src_size if src_size is not None else Vector2(surf.get_size())
@@ -365,7 +368,7 @@ class TransformedView:
                         int(src.get_height() * scaling_factor.y),
                     ),
                 )
-            if self._cache_surfaces:
+            if self._cache_surfaces or cache:
                 self._cache[cache_key] = src
                 self._memory_usage += src.get_width() * src.get_height() * 4
                 LOG.debug(

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

@@ -6,6 +6,8 @@ import pygame
 
 
 class Input(Enum):
+    """Capture all possible inputs based on typical gamepad layouts."""
+
     UP = 0
     DOWN = 1
     LEFT = 2
@@ -74,11 +76,24 @@ class InputManager:
         self._inputs_schemes = []
 
     def add_input_scheme(self, scheme: InputScheme) -> None:
+        """Add an input scheme to this manager."""
         self._inputs_schemes.append(scheme)
 
     def process_events(
         self, events: list[pygame.event.Event] | None = None
     ) -> list[pygame.event.Event]:
+        """Query and process all pygame events that are relevant for input.
+
+        Events may be provided or queried directly from pygame. Processing of
+        events is delegated to the input schemes.
+
+        Args:
+            events: List of pygame events or None. When None is passed, the
+            inputs will be queried from ``pygame.event``.
+
+        Returns:
+            A list with all pygame events.
+        """
         if events is None or not events:
             events = [e for e in pygame.event.get()]
 
@@ -95,24 +110,29 @@ class InputManager:
         return events
 
     def pressed(self, button: Input, player: Player = Player.P1) -> bool:
+        """Return True when the requested input has been newly pressed."""
         return (
             self._new_keys[player][button] != 0 and self._last_keys[player][button] == 0
         )
 
     def held(self, button: Input, player: Player = Player.P1) -> bool:
+        """Return True when the requested input has been held."""
         return self._new_keys[player][button] != 0
 
     def released(self, button: Input, player: Player = Player.P1) -> bool:
+        """Return True when the requested input is no longer held."""
         return (
             self._last_keys[player][button] != 0 and self._new_keys[player][button] == 0
         )
 
     def get_value(self, button: Input, player: Player = Player.P1) -> float:
+        """Return the value of the requested input."""
         return self._new_keys[player][button]
 
     def set_value(
         self, value: float, button: Input, player: Player = Player.P1
     ) -> None:
+        """Set the value for the requested input."""
         self._new_keys[player][button] = value