mima-engine 0.4.0__py3-none-any.whl

mima/standalone/multicolumn_list.py

@@ -0,0 +1,54 @@
+def compute_visible_area(
+    prev: tuple[int, int],
+    cursor: int,
+    dim: tuple[int, int],
+    list_sizes: tuple[int, int],
+) -> tuple[int, int]:
+    """Return first (inclusive) and last (exclusive) visible index of a list.
+
+    Args:
+        prev: The previous first and last visible item.
+        cursor: The selected item index.
+        dim: The dimension in which the list should be displayed.
+        list_sizes: Previous size of the list and current size of the list.
+
+    Returns:
+        The new first and last visible indicies.
+
+    Raises:
+        ValueError on an unhandled case
+    """
+
+    target_cursor = cursor
+    first, last = prev
+    n_rows, n_cols = dim
+    capacity = n_rows * n_cols
+
+    if list_sizes[0] > list_sizes[1]:
+        # List became smaller
+        cursor = min(cursor, list_sizes[1] - 1)
+        last = list_sizes[1]
+        first = last - capacity + last % n_cols
+
+    if first <= cursor < first + capacity:
+        # Cursor already within visible area
+        last = first + capacity
+    elif cursor >= last:
+        # Cursor below current visible area
+        last = cursor + (n_cols - cursor % n_cols)
+        first = last - capacity
+    elif cursor < first:
+        # Cursor above current visible area
+        first = cursor - cursor % n_cols
+        last = first + capacity
+    else:
+        msg = (
+            f"Unhandled case: prev=({prev}), cursor={target_cursor}, dim={dim}, "
+            f"old_list_size={list_sizes[0]}, new_list_size={list_sizes[1]}"
+        )
+        raise ValueError(msg)
+
+    first = max(0, first)
+    last = min(list_sizes[1], last)
+
+    return first, last

mima/standalone/pixel_font.py

@@ -0,0 +1,84 @@
+import pygame
+from pygame import BLEND_RGBA_MIN, Vector2
+from typing_extensions import TYPE_CHECKING, Protocol, Union
+
+if TYPE_CHECKING:
+    from pygame import Surface
+
+TRANSPARENT_COLOR = (254, 252, 253)
+
+
+class Renderer(Protocol):
+    def draw_surface(
+        self,
+        pos: Vector2,
+        surf: pygame.Surface,
+        *,
+        src_pos: Vector2 | None = None,
+        src_size: Vector2 | None = None,
+        scale: float = 1.0,
+        angle: float = 0,
+        special_flags: int = 0,
+    ) -> None: ...
+
+
+class PixelFont:
+    def __init__(self, image: pygame.Surface, font_size: tuple[int, int]) -> None:
+        self._image = image
+        self._font_size = font_size
+
+        self._colorized: dict[tuple[int, int, int, int], pygame.Surface] = {
+            (255, 255, 255, 255): self._image
+        }
+
+    def draw_text(
+        self,
+        pos: Vector2,
+        text: str,
+        display: Union[Renderer, "Surface"],
+        color: tuple[int, int, int, int] | None = None,
+    ) -> None:
+        if color is None:
+            color = (255, 255, 255, 255)
+        font = self._colorized.get(color)
+        if font is None:
+            font = self._image.copy()
+            font.fill(color, special_flags=BLEND_RGBA_MIN)
+            self._colorized[color] = font
+
+        surf = pygame.Surface((len(text) * self._font_size[0], self._font_size[1]))
+        surf.fill(TRANSPARENT_COLOR)
+        for i, c in enumerate(text):
+            sx = ((ord(c) - 32) % 16) * self._font_size[0]
+            sy = ((ord(c) - 32) // 16) * self._font_size[1]
+            surf.blit(font, (i * self._font_size[0], 0), ((sx, sy), self._font_size))
+        surf.set_colorkey(TRANSPARENT_COLOR)
+        if isinstance(display, pygame.Surface):
+            display.blit(surf, pos)
+        else:
+            display.draw_surface(pos, surf)
+
+    def draw_text_to_surface(
+        self,
+        text: str,
+        color: tuple[int, int, int, int] | None = None,
+        surface: pygame.Surface | None = None,
+    ) -> pygame.Surface:
+        if surface is None:
+            surface = pygame.Surface(
+                (len(text) * self._font_size[0], self._font_size[1])
+            )
+            surface.fill(TRANSPARENT_COLOR)
+            surface.set_colorkey(TRANSPARENT_COLOR)
+
+        self.draw_text(Vector2(), text, surface, color)
+
+        return surface
+
+    @property
+    def width(self) -> int:
+        return self._font_size[0]
+
+    @property
+    def height(self) -> int:
+        return self._font_size[1]

mima/standalone/scripting.py

@@ -0,0 +1,145 @@
+from enum import Enum
+
+
+class Command:
+    """A script that can be used to interact with the game engine.
+
+    Args:
+        scopes: The scopes this command should be added to.
+
+    Attributes:
+        started: Indicates if this command has started.
+        completed: Indicates if this command has completed.
+        interruptible: Indicates if this command can be finished before it has
+            completed (it still can be forced to complete, regardless of this
+            flag).
+        scopes: A list containing different command scopes. This is to be
+            interpreted by the game engine, but can, e.g., be used to
+            differentiate between different players in a split-screen
+            multiplayer session.
+
+    """
+
+    def __init__(self, scopes: list[int] | None = None) -> None:
+        self.started: bool = False
+        self.completed: bool = False
+        self.interruptible: bool = False
+        self.scopes: list[int] = scopes if scopes else [0]
+
+    def start(self) -> None:
+        """Start this command in the next frame."""
+        return
+
+    def _start(self) -> None:
+        """Prepare for start and start this command (internal function)."""
+        self.started = True
+        self.start()
+
+    def update(self, elapsed_time: float) -> bool:
+        """Update this command."""
+        return False
+
+    def finalize(self) -> None:
+        """Finalize the operation of this command and clean-up."""
+        pass
+
+    def set_scopes(self, scopes: list[int]) -> None:
+        """Set or override the scopes variable of this command."""
+        self.scopes = scopes
+
+
+class CompleteWhen(Enum):
+    ALL_COMPLETED = 0
+    ANY_COMPLETED = 1
+    FIRST_COMPLETED = 2
+
+
+class CommandParallel(Command):
+    """A script that executes multiple commands in parallel.
+
+    This command completes based on different termination conditions. It either
+    completes after all subcommands are completed, after any subcommand is
+    completed, or if the first command in the list is completed.
+
+    """
+
+    def __init__(
+        self,
+        cmds: list[Command],
+        completed_when: CompleteWhen = CompleteWhen.ALL_COMPLETED,
+        scopes: list[int] | None = None,
+    ) -> None:
+        super().__init__(scopes)
+
+        self._cmds: list[Command] = cmds
+        self._completed_when: CompleteWhen = completed_when
+
+    def start(self) -> None:
+        for cmd in self._cmds:
+            cmd.start()
+
+    def update(self, elapsed_time: float) -> bool:
+        for cmd in self._cmds:
+            cmd.update(elapsed_time)
+
+        if self._completed_when == CompleteWhen.ALL_COMPLETED:
+            self.completed = True
+            for cmd in self._cmds:
+                self.completed = self.completed and cmd.completed
+        elif self._completed_when == CompleteWhen.ANY_COMPLETED:
+            self.completed = False
+            for cmd in self._cmds:
+                self.completed = self.completed or cmd.completed
+        elif self._completed_when == CompleteWhen.FIRST_COMPLETED:
+            self.completed = self._cmds[0].completed
+        else:
+            msg = f"Unknown termination condition: {self._completed_when}"
+            raise ValueError(msg)
+
+        return self.completed
+
+    def set_scopes(self, scopes: list[int]) -> None:
+        self.scopes = scopes
+        for cmd in self._cmds:
+            cmd.set_scopes(scopes)
+
+
+class ScriptProcessor:
+    def __init__(self) -> None:
+        self._commands: dict[int, list[Command]] = {}
+        self._script_active: dict[int, bool] = {}
+
+    def add_command(self, cmd: Command, scopes: list[int] | None = None) -> None:
+        if scopes:
+            cmd.set_scopes(scopes)
+
+        for scope in cmd.scopes:
+            self._commands.setdefault(scope, []).append(cmd)
+
+    def process_command(self, elapsed_time: float) -> bool:
+        for scope in self._commands:
+            if not self._commands[scope]:
+                self._script_active[scope] = False
+                continue
+
+            self._script_active[scope] = True
+            if not self._commands[scope][0].completed:
+                if not self._commands[scope][0].started:
+                    self._commands[scope][0]._start()
+                else:
+                    self._commands[scope][0].update(elapsed_time)
+            else:
+                self._commands[scope][0].finalize()
+                self._commands[scope].pop()
+                self._script_active[scope] = False
+
+        return any(list(self._script_active.values()))
+
+    def complete_command(self, scope: int, force: bool = False) -> bool:
+        if scope not in self._commands or not self._commands[scope]:
+            return True
+
+        if self._commands[scope][0].interruptible or force:
+            self._commands[scope][0].completed = True
+            return True
+        return False

mima/standalone/spatial.py

@@ -0,0 +1,186 @@
+import logging
+import math
+
+from pygame import Vector2
+from typing_extensions import Generic, TypeVar, overload
+
+LOG = logging.getLogger(__name__)
+T = TypeVar("T")
+
+
+class SpatialGrid(Generic[T]):
+    def __init__(self, world_size: Vector2, cell_size: int) -> None:
+        self._world_size: Vector2 = world_size
+        self._cell_size: int = cell_size
+
+        self._n_cols = int(math.ceil(world_size.x / cell_size))
+        self._n_rows = int(math.ceil(world_size.y / cell_size))
+
+        self._cells: list[list[T]] = [[] for _ in range(self._n_cols * self._n_rows)]
+        self._object_map: dict[T, list[int]] = {}
+        self.n_objects = 0
+
+    def insert(self, obj: T, pos: Vector2, size: Vector2 | None = None) -> None:
+        """Insert object at given position in the grid."""
+        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) -> 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, new_pos: Vector2, size: Vector2 | None = None) -> None:
+        """Move object to a new position in the grid."""
+
+        old_indices = self._object_map.get(obj)
+        if old_indices is None:
+            LOG.warning(
+                "Objects %s not in grid. Performing insertion instead.", str(obj)
+            )
+            return self.insert(obj, new_pos, size)
+
+        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(
+            "Object %s (%s) moving from cells %s to %s",
+            str(obj),
+            new_pos,
+            old_indices,
+            new_indices,
+        )
+        for idx in old_indices:
+            if obj in self._cells[idx]:
+                self._cells[idx].remove(obj)
+
+        for idx in new_indices:
+            self._cells[idx].append(obj)
+
+        self._object_map[obj] = new_indices
+
+    def get_grid_index(self, pos: Vector2) -> int:
+        x, y = self.get_grid_coords(pos)
+        return x + y * self._n_cols
+
+    def get_grid_coords(self, pos: Vector2) -> tuple[int, int]:
+        return (
+            int(clamp(pos.x / self._cell_size, 0, self._n_cols - 1)),
+            int(clamp(pos.y / self._cell_size, 0, self._n_rows - 1)),
+        )
+
+    def get_all_objects(self) -> list[T]:
+        """Return all objects stored in the grid."""
+        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."""
+
+        sx = int(max(0, pos.x // self._cell_size))
+        sy = int(max(0, pos.y // self._cell_size))
+
+        # Clamp correctly here
+        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))
+
+        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
+    ) -> list[tuple[tuple[int, int], list[T]]]:
+        """Return all cells in the area defined by pos and size."""
+        tl = self.get_grid_coords(pos)
+        br = self.get_grid_coords(pos + size)
+        clamped_tl = (
+            clamp(tl[0], 0, self._n_cols - 1),
+            clamp(tl[1], 0, self._n_rows - 1),
+        )
+        clamped_br = (
+            clamp(br[0], 0, self._n_cols - 1),
+            clamp(br[0], 0, self._n_rows - 1),
+        )
+
+        results = [
+            ((x, y), self._cells[x + y * self._n_cols])
+            for y in range(clamped_tl[1], clamped_br[1] + 1)
+            for x in range(clamped_tl[0], clamped_br[0] + 1)
+        ]
+
+        return results
+
+    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
+
+
+class SpatialHash(Generic[T]):
+    def __init__(self, cell_size: int):
+        self._cell_size: int = cell_size
+        self._cells: dict[tuple[int, int], list[T]] = {}
+
+    def _hash(self, pos: Vector2) -> tuple[int, int]:
+        return (int(pos.x) // self._cell_size, int(pos.y) // self._cell_size)
+
+
+@overload
+def clamp(val: int, low: int, high: int) -> int: ...
+
+
+@overload
+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/standalone/sprite.py

@@ -0,0 +1,158 @@
+from enum import Enum
+
+from pygame import Surface, Vector2
+from typing_extensions import Any, Generic, Protocol, TypeVar
+
+GS = TypeVar("GS", bound=Enum)
+D = TypeVar("D", bound=Enum)
+
+
+class Renderer(Protocol):
+    def draw_surface(
+        self,
+        pos: Vector2,
+        surf: Surface,
+        *,
+        src_pos: Vector2 | None = None,
+        src_size: Vector2 | None = None,
+        scale: float = 1.0,
+        angle: float = 0,
+        cache: bool = False,
+        special_flags: int = 0,
+    ) -> None: ...
+
+
+class SpriteData:
+    def __init__(self) -> None:
+        self.duration: list[float] = []
+        self.offset: list[Vector2] = []
+        self.image: list[Surface] = []
+        self.size: list[Vector2] = []
+        self.frame_id: list[int] = []
+        self.hitboxes: list[list[dict]] = []
+
+    def n_frames(self) -> int:
+        return len(self.duration)
+
+
+class SpriteSet(Generic[D]):
+    def __init__(self) -> None:
+        self.data: dict[D, SpriteData] = {}
+
+    def __getitem__(self, direction: D) -> SpriteData:
+        return self.data[direction]
+
+
+class AnimatedSprite(Generic[GS, D]):
+    def __init__(self) -> None:
+        self._last_graphic_state: GS | None = None
+        self._last_direction: D | None = None
+
+        self.sprites: dict[GS, SpriteSet] = {}
+        self._timer: float = 0.0
+        self._frame: int = -1
+        self._src_pos: Vector2 = Vector2()
+        self._src_size: Vector2 = Vector2()
+        self._image: Surface | None = None
+        self._scaled_image: Surface | None = None
+        self._scale: float = 1.0
+        self._scaled_size: tuple[int, int] = (0, 0)
+
+    def update(self, elapsed_time: float, graphic_state: GS, direction: D) -> bool:
+        if self._last_graphic_state is None:
+            self._last_graphic_state = graphic_state
+        if self._last_direction is None:
+            self._last_direction = direction
+
+        gs = self.sprites.get(graphic_state)
+        if gs is None:
+            msg = (
+                f"Sprite has no {graphic_state=}. Available states are "
+                f"{self.sprites.keys()}"
+            )
+            raise ValueError(msg)
+        data = gs[direction]
+        update_vals = True
+        if (
+            graphic_state == self._last_graphic_state
+            and direction == self._last_direction
+        ):
+            self._timer -= elapsed_time
+            if self._timer <= 0.0:
+                self._frame = (self._frame + 1) % data.n_frames()
+                self._timer += data.duration[self._frame]
+            else:
+                update_vals = False
+
+        else:
+            # Something changed
+            self._frame = 0
+            self._timer = data.duration[self._frame]
+
+        if update_vals:
+            self._src_pos = data.offset[self._frame]
+            self._src_size = data.size[self._frame]
+            self._image = data.image[self._frame]
+            # self._scale_image()
+
+        self._last_graphic_state = graphic_state
+        self._last_direction = direction
+
+        return update_vals
+
+    def draw(self, pos: Vector2, ttv: Renderer, cache: bool = False) -> None:
+        if self._image is None:
+            return
+
+        ttv.draw_surface(
+            pos,
+            self._image,
+            src_pos=self._src_pos,
+            src_size=self._src_size,
+            scale=self._scale,
+            cache=cache,
+        )
+
+    def reset(self) -> None:
+        self._frame = -1
+        self._timer = 0.0
+
+    def __getitem__(self, graphic_state: GS) -> SpriteSet:
+        return self.sprites[graphic_state]
+
+    def add_frame(
+        self, graphic_state: GS, direction: D, frame_data: dict[str, Any]
+    ) -> None:
+        sprite_set = self.sprites.setdefault(graphic_state, SpriteSet())
+        sprite_data = sprite_set.data.setdefault(direction, SpriteData())
+        sprite_data.duration.append(frame_data["duration"])
+        sprite_data.offset.append(Vector2(frame_data["offset"]))
+        sprite_data.size.append(Vector2(frame_data["size"]))
+        sprite_data.image.append(frame_data["image"])
+        sprite_data.frame_id.append(frame_data["frame_id"])
+        hitboxes = frame_data.get("collision", [])
+        sprite_data.hitboxes.append(hitboxes)
+
+    def set_scale(self, scale: float) -> None:
+        self._scale = scale
+        # self._scale_image()
+
+    def get_size(self) -> Vector2:
+        if self._src_size is not None:
+            return self._src_size * self._scale
+        return Vector2()
+
+    # def _scale_image(self) -> None:
+    #     if self._image is None:
+    #         self._scaled_image = None
+    #         self._scaled_size = (0, 0)
+    #         return
+    #     if self._scale == 1.0:
+    #         self._scaled_image = self._image
+    #         self._scaled_size = self._image.get_size()
+    #         return
+    #     self._scaled_size = (
+    #         int((size := self._image.get_size())[0] * self._scale),
+    #         int(size[1] * self._scale),
+    #     )
+    #     self._scaled_image = pygame.transform.scale(self._image, self._scaled_size)