mima-engine 0.1.0__py3-none-any.whl

mima/scripts/commands/give_item.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ..command import Command
+
+if TYPE_CHECKING:
+    from ...objects.dynamic import Dynamic
+
+
+class CommandGiveItem(Command):
+    def __init__(self, item_name: str, dynamic: Optional[Dynamic] = None):
+        super().__init__()
+
+        self._item_name: str = item_name
+
+        if dynamic is None:
+            dynamic = self.engine.player
+
+        self._dynamic: Dynamic = dynamic
+
+    def start(self):
+        self.engine.give_item(self._item_name)
+        self.completed = True

mima/scripts/commands/give_resource.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, Optional
+
+from ..command import Command
+
+if TYPE_CHECKING:
+    from ...objects.dynamic import Dynamic
+
+
+class CommandGiveResource(Command):
+    def __init__(self, dynamic: Optional[Dynamic] = None, **resources: Dict[str, int]):
+        super().__init__()
+
+        if dynamic is None:
+            dynamic = self.engine.player
+
+        self._dynamic: Dynamic = dynamic
+        self._health: int = resources.get("health", 0)
+        self._magic: int = resources.get("magic", 0)
+        self._stamina: int = resources.get("stamina", 0)
+        self._arrows: int = resources.get("arrows", 0)
+        self._bombs: int = resources.get("bombs", 0)
+        self._coins: int = resources.get("coins", 0)
+        self._keys: int = resources.get("keys", 0)
+
+    def start(self):
+        self._dynamic.attributes.health = min(
+            self._dynamic.attributes.health + self._health,
+            self._dynamic.attributes.health_max,
+        )
+        self._dynamic.attributes.magic = min(
+            self._dynamic.attributes.magic + self._magic,
+            self._dynamic.attributes.magic_max,
+        )
+        self._dynamic.attributes.stamina = min(
+            self._dynamic.attributes.stamina + self._stamina,
+            self._dynamic.attributes.stamina_max,
+        )
+        self._dynamic.attributes.arrows = min(
+            self._dynamic.attributes.arrows + self._arrows,
+            self._dynamic.attributes.arrows_max,
+        )
+        self._dynamic.attributes.bombs = min(
+            self._dynamic.attributes.bombs + self._bombs,
+            self._dynamic.attributes.bombs_max,
+        )
+        self._dynamic.attributes.coins += self._coins
+        self._dynamic.attributes.keys += self._keys
+
+        self.completed = True

mima/scripts/commands/move_map.py

@@ -0,0 +1,152 @@
+from ...maps.transition_map import TransitionMap
+from ...objects.dynamic import Dynamic
+from ...util.constants import (
+    HEIGHT,
+    MOVE_MAP_DURATION,
+    TILE_HEIGHT,
+    TILE_WIDTH,
+    WIDTH,
+)
+from ..command import Command
+
+
+class CommandMoveMap(Command):
+    def __init__(
+        self,
+        new_map_name: str,
+        obj: Dynamic,
+        target_px: float,
+        target_py: float,
+        vx: float,
+        vy: float,
+    ):
+        super().__init__()
+
+        self.src_map = self.engine.scene.tilemap
+        self.dst_map = self.engine.assets.get_map(new_map_name)
+        self.obj: Dynamic = obj
+        self.vx: float = vx
+        self.vy: float = vy
+        self.start_px: float = 0
+        self.start_py: float = 0
+        self.start_ox: float = 0
+        self.start_oy: float = 0
+        self.target_px: float = target_px
+        self.target_py: float = target_py
+        self.target_ox: float = 0
+        self.target_oy: float = 0
+        self.final_px: float = target_px
+        self.final_py: float = target_py
+
+        if self.vx == 0 and self.vy == 0:
+            # Error
+            self.completed = True
+            self.started = True
+
+        self.duration: float = MOVE_MAP_DURATION
+        self.time_so_far: float = 0.0
+
+    def start(self) -> None:
+        # Prevent circular import
+        # from ...maps.transition_map import TransitionMap
+
+        self.start_ox = self._get_offset_x(self.obj.px)
+        self.start_oy = self._get_offset_y(self.obj.py)
+        self.target_ox = self._get_offset_x(self.target_px)
+        self.target_oy = self._get_offset_y(self.target_py)
+        self.start_px = self.obj.px
+        self.start_py = self.obj.py
+
+        # print(
+        #     f"start_pos=({self.start_px:.1f}, {self.start_py:.1f}), "
+        #     f"tar_pos=({self.target_px:.1f}, {self.target_py:.1f}), "
+        #     f"start_off=({self.start_ox:.1f}, {self.start_oy:.1f}), "
+        #     f"tar_off=({self.target_ox:.1f}, {self.target_oy:.1f})"
+        # )
+
+        if self.vx != 0:
+            if self.vx < 0:
+                self.target_px -= self.target_ox
+            else:
+                self.target_px += self.start_ox
+            self.target_py = self.start_py
+
+        elif self.vy != 0:
+            self.target_px = self.start_px
+            if self.vy < 0:
+                self.target_py -= self.target_oy + 1
+            else:
+                self.target_py += self.start_oy + 1
+
+        self.obj.solid_vs_dyn = False
+        self.obj.solid_vs_map = False
+        self.obj.vx = self.obj.vy = 0
+        self.engine.teleport_triggered = True
+        self.engine.scene.tilemap = TransitionMap(
+            self.src_map, self.dst_map, self.vx, self.vy
+        )
+        self.engine.scene.delete_map_dynamics()
+
+    def update(self, elapsed_time):
+        self.time_so_far += elapsed_time
+        rela_time = self.time_so_far / self.duration
+        if rela_time > 1.0:
+            rela_time = 1.0
+
+        self.obj.px = (
+            self.target_px - self.start_px
+        ) * rela_time + self.start_px
+        self.obj.py = (
+            self.target_py - self.start_py
+        ) * rela_time + self.start_py
+
+        ox = self._get_offset_x(self.obj.px)
+        oy = self._get_offset_y(self.obj.py)
+        self.obj.extra_ox = ox - self.start_ox
+        self.obj.extra_oy = oy - self.start_oy
+
+        if self.time_so_far >= self.duration:
+            self.completed = True
+        else:
+            self.engine.teleport_triggered = True
+
+        # print(f"obj_pos=({self.obj.px:.1f}, {self.obj.py:.1f})")
+
+    def finalize(self):
+        if self.vy != 0:
+            self.obj.px = self.target_px
+            if self.vy > 0:
+                self.obj.py = self.target_py - self.start_oy - 1
+            else:
+                self.obj.py = self.target_py + self.target_oy + 1
+
+        self.obj.vx = self.obj.vy = 0
+        self.obj.solid_vs_dyn = True
+        self.obj.solid_vs_map = True
+        self.obj.extra_ox = self.obj.extra_oy = 0
+        self.engine.scene.change_map(
+            self.dst_map.name, self.final_px, self.final_py
+        )
+
+    def _get_offset_x(self, px: float) -> float:
+        visible_tiles = WIDTH / TILE_WIDTH
+        offset = px - visible_tiles / 2.0
+
+        if offset < 0:
+            offset = 0
+        if offset > self.src_map.width - visible_tiles:
+            offset = self.src_map.width - visible_tiles
+
+        return offset
+
+    def _get_offset_y(self, py: float) -> float:
+        visible_tiles = HEIGHT / TILE_HEIGHT - 1
+        offset = py - visible_tiles / 2.0
+
+        if offset < 0:
+            offset = 0
+        if offset > self.src_map.height - visible_tiles:
+            offset = self.src_map.height - visible_tiles
+
+        offset -= 1
+        return offset

mima/scripts/commands/move_to.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ...scripts.command import Command
+
+if TYPE_CHECKING:
+    from ...objects.dynamic import Dynamic
+
+
+class CommandMoveTo(Command):
+    def __init__(
+        self,
+        obj: Dynamic,
+        target_px: float,
+        target_py: float,
+        duration: float = 0.0,
+    ):
+        super().__init__()
+
+        self.obj: Dynamic = obj
+        self.start_px: float = 0.0
+        self.start_py: float = 0.0
+        self.target_px: float = target_px
+        self.target_py: float = target_py
+
+        self.duration: float = max(duration, 0.001)
+        self.time_so_far: float = 0.0
+
+    def start(self):
+        self.start_px = self.obj.px
+        self.start_py = self.obj.py
+
+    def update(self, elapsed_time: float):
+        self.time_so_far += elapsed_time
+        relatime = min(1.0, self.time_so_far / self.duration)
+
+        self.obj.px = (self.target_px - self.start_px) * relatime + self.start_px
+        self.obj.py = (self.target_py - self.start_py) * relatime + self.start_py
+        self.obj.vx = (self.target_px - self.start_px) / self.duration
+        self.obj.vy = (self.target_py - self.start_py) / self.duration
+
+        if self.time_so_far >= self.duration:
+            self.completed = True
+
+    def finalize(self):
+        self.obj.px = self.target_px
+        self.obj.py = self.target_py
+        self.obj.vx = self.obj.vy = 0.0

mima/scripts/commands/oneway_move.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import math
+from typing import TYPE_CHECKING
+
+from ...scripts.command import Command
+from ...util.constants import ONEWAY_SPEED_BOOST
+
+if TYPE_CHECKING:
+    from ...objects.dynamic import Dynamic
+
+
+class CommandOnewayMove(Command):
+    def __init__(self, obj: Dynamic, vx: float, vy: float):
+        super().__init__()
+
+        self.obj: Dynamic = obj
+        self.vx: float = vx
+        self.vy: float = vy
+        self.start_px: float = 0.0
+        self.start_py: float = 0.0
+        self.target_px: float = 0.0
+        self.target_py: float = 0.0
+        self.distance: float = 0.0
+
+    def start(self):
+        self.obj.solid_vs_map = False
+        self.obj.solid_vs_dyn = False
+        self.obj.vx = self.obj.vy = 0.0
+        self.obj.vz = 10.0
+
+        self.start_px = self.obj.px
+        self.start_py = self.obj.py
+        self.target_px = self.obj.px + self.vx
+        self.target_py = self.obj.py + self.vy
+
+        dx = self.target_px - self.start_px
+        dy = self.target_py - self.start_py
+        self.distance = math.sqrt(dx * dx + dy * dy)
+
+    def update(self, elapsed_time):
+        self.obj.px += self.vx * elapsed_time * ONEWAY_SPEED_BOOST
+        self.obj.py += self.vy * elapsed_time * ONEWAY_SPEED_BOOST
+
+        dx = self.obj.px - self.start_px
+        dy = self.obj.py - self.start_py
+        distance = math.sqrt(dx * dx + dy * dy)
+
+        if distance >= self.distance:
+            self.completed = True
+
+    def finalize(self):
+        self.obj.px = self.target_px
+        self.obj.py = self.target_py
+        self.obj.vx = self.obj.vy = 0.0
+        self.obj.solid_vs_dyn = True
+        self.obj.solid_vs_map = True

mima/scripts/commands/parallel.py

@@ -0,0 +1,53 @@
+from typing import List
+from ..command import Command
+
+
+class CommandParallel(Command):
+    ALL_COMPLETED: int = 0
+    ANY_COMPLETED: int = 1
+    FIRST_COMPLETED: int = 2
+
+    def __init__(self, cmds: List[Command], completed_when: int = ALL_COMPLETED):
+        super().__init__()
+        self._cmds: List[Command] = cmds
+        self._completed_when: int = completed_when
+
+    def start(self):
+        for cmd in self._cmds:
+            cmd.start()
+
+    def update(self, delta_time):
+        for cmd in self._cmds:
+            cmd.update(delta_time)
+
+        if self._completed_when == self.ALL_COMPLETED:
+            self._check_for_all()
+        elif self._completed_when == self.ANY_COMPLETED:
+            self._check_for_any()
+        elif self._completed_when == self.FIRST_COMPLETED:
+            self._check_for_first()
+        else:
+            raise ValueError(
+                f"Unknown value {self._completed_when} for " "attribute _completed_when"
+            )
+
+    def finalize(self):
+        for cmd in self._cmds:
+            cmd.finalize()
+
+    def _check_for_all(self):
+        completed = True
+        for cmd in self._cmds:
+            completed = completed and cmd.completed
+
+        self.completed = completed
+
+    def _check_for_any(self):
+        completed = False
+        for cmd in self._cmds:
+            completed = completed or cmd.completed
+
+        self.completed = completed
+
+    def _check_for_first(self):
+        self.completed = self._cmds[0].completed

mima/scripts/commands/play_sound.py

@@ -0,0 +1,13 @@
+from ..command import Command
+
+
+class CommandPlaySound(Command):
+    def __init__(self, sound: str, delay: float = 0.0):
+        super().__init__()
+
+        self._sound_to_play: str = sound
+        self._delay: float = delay
+
+    def start(self):
+        self.engine.audio.play_sound(self._sound_to_play, self._delay)
+        self.completed = True

mima/scripts/commands/present_item.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ...objects.projectile import Projectile
+from ...scripts.command import Command
+from ...types.graphic_state import GraphicState
+
+if TYPE_CHECKING:
+    from ...objects.dynamic import Dynamic
+
+
+class CommandPresentItem(Command):
+    def __init__(self, item_name: str, dynamic: Optional[Dynamic] = None):
+        super().__init__()
+
+        if dynamic is None:
+            dynamic = self.engine.player
+
+        self._dynamic: Dynamic = dynamic
+        self._item_name: str = item_name
+        self._item_sprite: Optional[Projectile] = None
+
+    def start(self):
+        item = self.engine.get_item(self._item_name)
+        self._item_sprite = Projectile(
+            self._dynamic.px,
+            self._dynamic.py - 1,
+            0,
+            0,
+            3600,
+            self._dynamic.alignment,
+        )
+        self._item_sprite.layer = 2
+        self._item_sprite.sprite.name = item.sprite_name
+        self._item_sprite.sprite.ox = item.sprite_ox
+        self._item_sprite.sprite.oy = item.sprite_oy
+        self._item_sprite.sprite.width = item.sprite_width
+        self._item_sprite.sprite.height = item.sprite_height
+        self._item_sprite.solid_vs_dyn = False
+        self._item_sprite.solid_vs_map = False
+        self._item_sprite.one_hit = False
+        self._item_sprite.damage = 0
+
+        self.engine.scene.add_projectile(self._item_sprite)
+        self._dynamic.lock_graphic_state(GraphicState.CELEBRATING)
+        self.completed = True
+
+    def finalize(self):
+        self._item_sprite.kill()
+        self._dynamic.unlock_graphic_state()

mima/scripts/commands/progress_quest.py

@@ -0,0 +1,12 @@
+from ..command import Command
+
+
+class CommandProgressQuest(Command):
+    def __init__(self, quest_name: str, new_state: int):
+        super().__init__()
+        self._quest_name: str = quest_name
+        self._new_state: int = new_state
+
+    def start(self):
+        self.engine.progress_quest(self._quest_name, self._new_state)
+        self.completed = True

mima/scripts/commands/quit_game.py

@@ -0,0 +1,8 @@
+from ..command import Command
+
+
+class CommandQuitGame(Command):
+    def start(self):
+        self.engine.game_state.save_to_disk(autosave=True)
+        self.engine.backend.terminate = True
+        self.completed = True

mima/scripts/commands/save_game.py

@@ -0,0 +1,13 @@
+from ...scripts.command import Command
+
+
+class CommandSaveGame(Command):
+    def start(self):
+        # print(self.engine.game_state._state["player"])
+        # print(self.engine.items)
+        for quest in self.engine.quests:
+            quest.save_state()
+        self.engine.game_state.save_to_disk()
+        self.completed = True
+
+        # print(self.engine.game_state._state["player"])

mima/scripts/commands/screen_fade.py

@@ -0,0 +1,65 @@
+from typing import Optional
+
+from ...objects.effects.colorize_screen import ColorizeScreen
+from ..command import Command
+from ...util.colors import BLACK,Color
+
+
+class CommandScreenFade(Command):
+    def __init__(
+        self,
+        duration: float = 0.5,
+        color: Optional[Color] = None,
+        fadein: bool = False,
+    ):
+        super().__init__()
+
+        self.duration: float = duration
+        if color is None:
+            color = self.engine.rtc.colors["gb_dark"]
+
+        self.color: Color = color
+        self.fadein: bool = fadein
+        self.time_so_far: float = 0.0
+        self._start: int = 0
+        self._end: int = 255
+        self._iter: int = 15
+
+        if fadein:
+            self._start = 255
+            self._end = 0
+            self._iter = -self._iter
+
+        # self._alpha = chain([i for i in range(self._start, self._end, self._iter)])
+
+        self._effect = ColorizeScreen()
+        # self.duration -= 0.1
+        self._effect.alpha = self._start
+
+    def start(self):
+        self.engine.scene.add_effect(self._effect)
+        self.engine.player.vx = 0
+        self.engine.player.vy = 0
+
+    def update(self, elapsed_time: float):
+        self.time_so_far += elapsed_time
+
+        progress = self.time_so_far / self.duration
+
+        alpha = progress * 256
+        if self.fadein:
+            alpha = 255 - alpha
+
+        self._effect.alpha = min(255, max(0, alpha))
+        # print(self, self._effect.alpha)
+
+        self.engine.player.vx = 0
+        self.engine.player.vy = 0
+
+        if self.time_so_far >= self.duration:
+            self._effect.alpha = self._end
+            self.completed = True
+
+    def finalize(self):
+        self.completed = True
+        self._effect.kill()

mima/scripts/commands/serial.py

@@ -0,0 +1,46 @@
+from typing import List, Union
+import logging
+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):
+        super().__init__()
+        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) < 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:
+            self._cmds[self._current].update(delta_time)
+        else:
+            self._current += 1
+            if self._current == len(self._cmds):
+                self.completed = True
+            else:
+                self._cmds[self._current].start()
+                if self._update_when[self._current-1] == self.START_AND_UPDATE:
+                    self._cmds[self._current].update(delta_time)
+
+    def finalize(self):
+        for cmd in self._cmds:
+            cmd.finalize()

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,14 @@
+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.player_state.save_map = self._map_name
+        self.engine.player_state.save_px = self._px
+        self.engine.player_state.save_py = self._py
+        self.completed = True

mima/scripts/commands/show_choices.py

@@ -0,0 +1,43 @@
+from typing import List
+from ...scripts.command import Command
+from ...types.keys import Key as K
+
+
+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._cursor_pos = (self._cursor_pos - 1) % len(self._options)
+        elif self.engine.keys.new_key_release(K.DOWN):
+            self._cursor_pos = (self._cursor_pos + 1) % len(self._options)
+        elif self.engine.keys.new_key_press(K.A):
+            self.completed = True
+        elif self.engine.keys.new_key_release(K.B):
+            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}")
+
+        self.engine.scene.show_dialog(lines)
+
+    def finalize(self):
+        self.engine.script.add_command(self._replies[self._cursor_pos])