mima-engine 0.4.0__py3-none-any.whl

mima/scripts/commands/serial.py

@@ -0,0 +1,69 @@
+import logging
+from typing import List, Optional, Union
+
+from ...types.player import Player
+from ..command import Command
+
+LOG = logging.getLogger(__name__)
+
+
+class CommandSerial(Command):
+    START_AND_UPDATE: int = 0
+    START_WITHOUT_UPDATE: int = 1
+
+    def __init__(
+        self,
+        cmds: List[Command],
+        update_when: Union[int, List[int]] = START_AND_UPDATE,
+        players: Optional[List[Player]] = None,
+    ):
+        super().__init__(players)
+        self._cmds: List[Command] = cmds
+
+        self._current: int = 0
+        self._update_when: List[int]
+        if not isinstance(update_when, list):
+            self._update_when = [
+                update_when for _ in range(len(self._cmds) - 1)
+            ]
+        else:
+            self._update_when = update_when
+
+        if len(self._update_when) + 1 < len(self._cmds):
+            LOG.warning(
+                "Unsufficient information for 'update_when' of serial command:"
+                f"cmds={self._cmds}, update_when={self._update_when}. Using "
+                "default value!"
+            )
+
+    def start(self):
+        self._cmds[self._current].start()
+
+    def update(self, delta_time):
+        if not self._cmds[self._current].completed:
+            # Not completed -> Update current command
+            self._cmds[self._current].update(delta_time)
+        else:
+            # Current command completed -> progress to next
+            self._current += 1
+            if self._current == len(self._cmds):
+                # Reached end? -> Finish serial command
+                self.completed = True
+            else:
+                # End not reached -> call start of next command
+                self._cmds[self._current].start()
+                if (
+                    self._update_when[self._current - 1]
+                    == self.START_AND_UPDATE
+                ):
+                    # Start the command already with update
+                    self._cmds[self._current].update(delta_time)
+
+    def finalize(self):
+        for cmd in self._cmds:
+            cmd.finalize()
+
+    def set_players(self, players: List[Player]):
+        self.players = players
+        for cmd in self._cmds:
+            cmd.set_players(players)

mima/scripts/commands/set_facing_direction.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ...types.direction import Direction
+from ..command import Command
+
+if TYPE_CHECKING:
+    from ...objects.dynamic import Dynamic
+
+
+class CommandSetFacingDirection(Command):
+    def __init__(self, dynamic: Dynamic, facing_direction: Direction):
+        super().__init__()
+
+        self._dynamic: Dynamic = dynamic
+        self._new_direction: Direction = facing_direction
+
+    def start(self):
+        self._dynamic.facing_direction = self._new_direction
+        self.completed = True

mima/scripts/commands/set_spawn_map.py

@@ -0,0 +1,17 @@
+from ...scripts.command import Command
+
+
+class CommandSetSavePosition(Command):
+    def __init__(self, map_name: str, px: float, py: float):
+        self._map_name = map_name
+        self._px = px
+        self._py = py
+
+    def start(self):
+
+        self.engine.memory.player_state[self.players[0]].save_map = (
+            self._map_name
+        )
+        self.engine.memory.player_state[self.players[0]].save_px = self._px
+        self.engine.memory.player_state[self.players[0]].save_py = self._py
+        self.completed = True

mima/scripts/commands/show_choices.py

@@ -0,0 +1,52 @@
+from typing import List
+
+from ...scripts.command import Command
+from ...types.keys import Key as K
+from ...types.player import Player
+
+
+class CommandShowChoices(Command):
+    def __init__(
+        self,
+        options: List[str],
+        replies: List[Command],
+        default_option: int = 0,
+    ):
+        super().__init__()
+
+        self.uninterruptible = True
+        self._options: List[str] = options
+        self._replies: List[Command] = replies
+        self._default_option: int = default_option
+
+        self._cursor_pos: int = 0
+
+    def update(self, elapsed_time: float):
+        if self.engine.keys.new_key_release(K.UP, self.players[0]):
+            self._cursor_pos = (self._cursor_pos - 1) % len(self._options)
+        elif self.engine.keys.new_key_release(K.DOWN, self.players[0]):
+            self._cursor_pos = (self._cursor_pos + 1) % len(self._options)
+        elif self.engine.keys.new_key_press(K.A, self.players[0]):
+            self.completed = True
+        elif self.engine.keys.new_key_release(K.B, self.players[0]):
+            self._cursor_pos = self._default_option
+            self.completed = True
+
+        lines = []
+        for idx, opt in enumerate(self._options):
+            if idx == self._cursor_pos:
+                lines.append(f"> {opt}")
+            else:
+                lines.append(f"  {opt}")
+        # for p in self.players:
+        self.engine.get_view().show_dialog(lines, self.players[0])
+
+    def finalize(self):
+        self.engine.script.add_command(
+            self._replies[self._cursor_pos], players=self.players
+        )
+
+    def set_players(self, players: List[Player]):
+        for cmd in self._replies:
+            cmd.set_players(players)
+        self.players = players

mima/scripts/commands/show_dialog.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional
+
+from ...scripts.command import Command
+from ...util.constants import DIALOG_CHARS_PER_LINE, DIALOG_N_LINES
+from ...util.functions import wrap_text
+
+if TYPE_CHECKING:
+    from ...types.player import Player
+
+
+class CommandShowDialog(Command):
+    def __init__(
+        self,
+        lines: List[str],
+        *,
+        no_auto_wrap: bool = False,
+        chars_per_line: int = DIALOG_CHARS_PER_LINE,
+        n_lines: int = DIALOG_N_LINES,
+    ):
+        super().__init__()
+
+        self.lines: List[str] = lines
+        self._current_lines: List[str] = []
+        self._no_auto_wrap: bool = no_auto_wrap
+        self._chars_per_line: int = chars_per_line
+        self._n_lines: int = n_lines
+        self._row: int = 0
+        self._char: int = 0
+        self._first_row: int = 0
+        self._last_row: int = self._n_lines
+
+        self._timer_reset = 0.01
+        self._timer = self._timer_reset
+        self._auto_scroll: bool = True
+        self._progress: bool = False
+        self._lines_changed: bool = True
+
+    def start(self):
+        if not self._no_auto_wrap:
+            one_liner = ""
+            for line in self.lines:
+                one_liner += f"{line.strip()} "
+
+            self.lines = wrap_text(one_liner, self._chars_per_line)
+        self._current_lines = [self.lines[0][0]]
+        self._char += 1
+        for p in self.players:
+            self.engine.get_view().show_dialog(self._current_lines, p)
+
+    def update(self, elapsed_time: float):
+        if self._auto_scroll:
+            self._timer -= elapsed_time
+            if self._timer <= 0.0:
+                self._timer += self._timer_reset
+
+                self._current_lines = []
+                for r in range(self._first_row, self._last_row):
+                    if r < self._row:
+                        self._current_lines.append(self.lines[r])
+                        continue
+
+                    line = ""
+
+                    for c in range(self._char + 1):
+                        if c + 1 >= self._char or c + 1 >= len(self.lines[r]):
+                            break
+                        line += self.lines[r][c]
+
+                    self._current_lines.append(line)
+
+                    if r + 1 >= self._row:
+                        break
+
+                self._char += 1
+                if self._char >= self._chars_per_line or self._char >= len(
+                    self.lines[r]
+                ):
+                    self._char = 0
+                    self._row += 1
+
+                if self._row >= self._n_lines + self._first_row:
+                    self._first_row += 1
+                    self._last_row += 1
+                if self._row >= len(self.lines):
+                    self._auto_scroll = False
+
+                # print(f"'{self._current_lines}'")
+                for p in self.players:
+                    self.engine.get_view().show_dialog(self._current_lines, p)
+        else:
+            if self._lines_changed:
+                self._current_lines = []
+                for r in range(self._first_row, self._last_row):
+                    if r >= len(self.lines):
+                        break
+                    self._current_lines.append(self.lines[r])
+                for p in self.players:
+                    self.engine.get_view().show_dialog(self._current_lines, p)
+                self._lines_changed = False
+
+            if self._progress:
+                self._first_row += self._n_lines
+                self._last_row += self._n_lines
+                self._progress = False
+                self._lines_changed = True
+
+    def can_complete(self, force: bool = False) -> bool:
+        if force:
+            return True
+        if self._auto_scroll:
+            self._auto_scroll = False
+        elif self._last_row >= len(self.lines):
+            return True
+        else:
+            self._progress = True
+        return False

mima/scripts/commands/take_coins.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ...scripts.command import Command
+
+if TYPE_CHECKING:
+    from ...objects.dynamic import Dynamic
+
+
+class CommandTakeCoins(Command):
+    def __init__(self, amount: int = 0, dynamic: Optional[Dynamic] = None):
+        super().__init__()
+
+        if dynamic is None:
+            dynamic = self.engine.player
+
+        self._amount: int = amount
+        self._dynamic: Dynamic = dynamic
+
+    def start(self):
+        self._dynamic.attributes.coins -= self._amount
+        self.completed = True

mima/scripts/script_processor.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from ..types.player import Player
+from .command import Command
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+
+
+class ScriptProcessor:
+    engine: MimaEngine
+
+    def __init__(self):
+        self.commands: Dict[Player : List[Command]] = {}
+
+    def add_command(
+        self, cmd: Command, *, players: Optional[List[Player]] = None
+    ):
+        if players is not None and players:
+            cmd.set_players(players)
+
+        for p in cmd.players:
+            self.commands.setdefault(p, []).append(cmd)
+        # self.commands.append(cmd)
+
+    def process_command(self, elapsed_time: float):
+        # for p in Player:
+        #     self.engine.trigger_script(False, p)
+        #     for cmd in self.commands:
+        #         if p in cmd.players or Player.P0 in cmd.players:
+        #             self.engine.trigger_script(True, p)
+        #             break
+        for p in self.commands:
+            if self.commands[p]:
+                self.engine.trigger_script(True, p)
+                if not self.commands[p][0].completed:
+                    if not self.commands[p][0].started:
+                        self.commands[p][0].start()
+                        self.commands[p][0].started = True
+                    else:
+                        self.commands[p][0].update(elapsed_time)
+                else:
+                    self.commands[p][0].finalize()
+                    self.commands[p].pop(0)
+                    self.engine.trigger_script(False, p)
+            else:
+                self.engine.trigger_script(False, p)
+
+    def complete_command(self, player: Player, force: bool = False):
+        if self.commands[player]:
+            # for cmd in self.commands:
+            #     if player in cmd.players or Player.P0 in cmd.players:
+
+            if self.commands[player][0].can_complete(force):
+                self.commands[player][0].completed = True
+                return True
+            else:
+                return False
+        return True

mima/standalone/camera.py

@@ -0,0 +1,153 @@
+from enum import Enum
+
+from pygame import Vector2
+from typing_extensions import Generic, Protocol, TypeVar
+
+
+class CameraTarget(Protocol):
+    def get_pos(self) -> Vector2: ...
+
+
+T = TypeVar("T", bound=CameraTarget)
+
+
+class CameraMode(Enum):
+    SIMPLE = 0  # No motion, just directly settable
+    EDGE_MOVE = 1  # Moves as target crosses boundary
+    LAZY_FOLLOW = 2  # Lazily follows the target
+    FIXED_SCREENS = 3  # Moves statically between screens
+    SLIDE_SCREENS = 4  # Moves statically between screens but with a fast transition
+
+
+class Camera(Generic[T]):
+    def __init__(self, view_size: Vector2, view_pos: Vector2 | None = None) -> None:
+        self._view_size = view_size
+        self._view_pos = Vector2(0, 0) if view_pos is None else view_pos
+        self._mode = CameraMode.SIMPLE
+        self._pos = Vector2(0, 0)
+        self._edge_trigger_dist = Vector2(1.0, 1.0)
+        self._world_boundary_pos = Vector2(0, 0)
+        self._world_boundary_size = Vector2(256, 240)
+        self._world_boundary_enabled: bool = False
+        self._screen_size = Vector2(16, 15)
+
+        self._lazy_follow_rate: float = 4.0
+        self._target: T | None = None
+
+    def set_mode(self, mode: CameraMode) -> None:
+        self._mode = mode
+
+    def get_mode(self) -> CameraMode:
+        return self._mode
+
+    def get_target(self) -> T | None:
+        return self._target
+
+    def get_pos(self) -> Vector2:
+        return self._pos
+
+    def get_view_pos(self) -> Vector2:
+        return self._view_pos
+
+    def get_view_size(self) -> Vector2:
+        return self._view_size
+
+    def set_view_size(self, size: Vector2) -> None:
+        self._view_size = size
+
+    def set_screen_size(self, size: Vector2):
+        self._screen_size = size
+
+    def get_screen_size(self) -> Vector2:
+        return self._screen_size
+
+    def set_target(self, target: T | None = None) -> None:
+        self._target = target
+
+    def set_world_boundary(self, pos: Vector2, size: Vector2) -> None:
+        self._world_boundary_pos = pos
+        self._world_boundary_size = size
+
+    def enable_world_boundary(self, enable: bool = True) -> None:
+        self._world_boundary_enabled = enable
+
+    def is_world_boundary_enabled(self) -> bool:
+        return self._world_boundary_enabled
+
+    def get_world_boundary_pos(self) -> Vector2:
+        return self._world_boundary_pos
+
+    def get_world_boundary_size(self) -> Vector2:
+        return self._world_boundary_size
+
+    def get_lazy_follow_rate(self) -> float:
+        return self._lazy_follow_rate
+
+    def set_lazy_follow_rate(self, rate: float) -> None:
+        self._lazy_follow_rate = rate
+
+    def set_edge_trigger_dist(self, edge: Vector2) -> None:
+        self._edge_trigger_dist = edge
+
+    def get_edge_trigger_dist(self) -> Vector2:
+        return self._edge_trigger_dist
+
+    def update(self, elapsed_time: float) -> bool:
+        if self._target is None:
+            return False
+
+        tpos = self._target.get_pos()
+        if self._mode == CameraMode.SIMPLE:
+            self._pos = tpos
+        elif self._mode == CameraMode.EDGE_MOVE:
+            overlap = tpos - self._pos
+            if overlap.x > self._edge_trigger_dist.x:
+                self._pos.x += overlap.x - self._edge_trigger_dist.x
+            if overlap.x < self._edge_trigger_dist.x:
+                self._pos.x += overlap.x + self._edge_trigger_dist.x
+            if overlap.y > self._edge_trigger_dist.y:
+                self._pos.y += overlap.y - self._edge_trigger_dist.y
+            if overlap.y < self._edge_trigger_dist.y:
+                self._pos.y += overlap.y + self._edge_trigger_dist.y
+        elif self._mode == CameraMode.LAZY_FOLLOW:
+            self._pos += (tpos - self._pos) * self._lazy_follow_rate * elapsed_time
+        elif self._mode == CameraMode.FIXED_SCREENS:
+            self._pos = Vector2(
+                int(tpos.x // self._screen_size.x) * int(self._screen_size.x),
+                int(tpos.y // self._screen_size.y) * int(self._screen_size.y),
+            ) + (self._view_size * 0.5)
+        elif self._mode == CameraMode.SLIDE_SCREENS:
+            screen = Vector2(
+                int(tpos.x // self._screen_size.x) * int(self._screen_size.x),
+                int(tpos.y // self._screen_size.y) * int(self._screen_size.y),
+            ) + (self._view_size * 0.5)
+            self._pos = (
+                (screen - self._pos) * self._lazy_follow_rate * 2.0 * elapsed_time
+            )
+
+        self._view_pos = self._pos - (self._view_size * 0.5)
+        if self._world_boundary_enabled:
+            self._view_pos = vclamp(
+                self._view_pos,
+                self._world_boundary_pos,
+                self._world_boundary_pos + self._world_boundary_size - self._view_size,
+            )
+
+        return (
+            tpos.x >= self._view_pos.x
+            and tpos.x < (self._view_pos.x + self._view_size.x)
+            and tpos.y >= self._view_pos.y
+            and tpos.y < (self._view_pos.y + self._view_size.y)
+        )
+
+
+def vclamp(val: Vector2, low: Vector2, high: Vector2) -> Vector2:
+    return Vector2(max(low.x, min(high.x, val.x)), max(low.y, min(high.y, val.y)))
+
+
+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))