mima-engine 0.4.0__py3-none-any.whl

mima/scripts/commands/add_quest.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..command import Command
+
+if TYPE_CHECKING:
+    from ...states.quest import Quest
+
+
+class CommandAddQuest(Command):
+    def __init__(self, quest: Quest):
+        super().__init__()
+
+        self._quest: Quest = quest
+
+    def start(self):
+        self.engine.add_quest(self._quest)
+        self.completed = True

mima/scripts/commands/change_map.py

@@ -0,0 +1,34 @@
+from typing import List, Optional
+
+from ...types.player import Player
+from ..command import Command
+
+
+class CommandChangeMap(Command):
+    def __init__(
+        self,
+        map_name: str,
+        spawn_px: float,
+        spawn_py,
+        players: Optional[List[Player]] = None,
+    ):
+        if players is None:
+            players = [Player.P1]
+
+        super().__init__(players)
+
+        self._map_name: str = map_name
+        self._spawn_px: float = spawn_px
+        self._spawn_py: float = spawn_py
+
+    def start(self):
+        self.engine.get_view().unload_map(self.players[0])
+        self.engine.get_view().load_map(
+            self._map_name, self._spawn_px, self._spawn_py, self.players[0]
+        )
+        # self.engine.change_map(self._map_name, self._spawn_px, self._spawn_py)
+        self.completed = True
+
+    def finalize(self):
+        self.engine.trigger_teleport(False, self.players[0])
+        self.engine.trigger_player_collision(False, self.players[0])

mima/scripts/commands/close_dialog.py

@@ -0,0 +1,9 @@
+from ..command import Command
+
+
+class CommandCloseDialog(Command):
+    def start(self):
+        for player in self.players:
+            self.engine.trigger_dialog(False, player)
+        self.engine.exit_dialog_active = False
+        self.completed = True

mima/scripts/commands/equip_weapon.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ..command import Command
+
+if TYPE_CHECKING:
+    from ...objects.creature import Creature
+    from ...types.weapon_slot import WeaponSlot
+    from ...usables.weapon import Weapon
+
+
+class CommandEquipWeapon(Command):
+    def __init__(self, weapon: Weapon, creature: Creature, slot: WeaponSlot):
+        super().__init__()
+
+        self._weapon: Weapon = weapon
+        self._target: Creature = creature
+        self._slot: WeaponSlot = slot
+
+    def start(self):
+        self._target.equip_weapon(self._slot, self._weapon)
+        self.completed = True

mima/scripts/commands/give_item.py

@@ -0,0 +1,26 @@
+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):
+        # if self._dynamic is None:
+        #     self._dynamic = self.engine.get_player(self.players[0])
+        self.engine.give_item(self._item_name, self.players[0])
+        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 typing import List, Optional
+
+from ...maps.transition_map import TransitionMap
+from ...objects.dynamic import Dynamic
+from ...types.player import Player
+from ...util.constants import HEIGHT, MOVE_MAP_DURATION, 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,
+        players: Optional[List[Player]] = None,
+    ):
+        super().__init__()
+
+        self.players = [obj.is_player()]
+        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 / self.engine.rtc.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 / self.engine.rtc.tile_width - 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,58 @@
+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
+    from ...types.player import Player
+
+
+class CommandOnewayMove(Command):
+    def __init__(self, obj: Dynamic, vx: float, vy: float, player: Player):
+        super().__init__([player])
+
+        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 = 7.5
+
+        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,66 @@
+from typing import List, Optional
+
+from ...types.player import Player
+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,
+        players: Optional[List[Player]] = None,
+    ):
+        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
+
+    def set_players(self, players: List[Player]):
+        self.players = players
+        for cmd in self._cmds:
+            cmd.set_players(players)

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,53 @@
+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__()
+
+        self._dynamic: Optional[Dynamic] = dynamic
+        self._item_name: str = item_name
+        self._item_sprite: Optional[Projectile] = None
+
+    def start(self):
+        if self._dynamic is None:
+            self._dynamic = self.engine.get_player(self.players[0])
+        item = self.engine.get_item(self._item_name)
+        self._item_sprite = Projectile(
+            self._dynamic.px,
+            self._dynamic.py - 1,
+            f"Present {item.name}",
+            sprite_name=item.sprite_name,
+            tilemap=self._dynamic.tilemap,
+            duration=3600,
+            alignment=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.get_view().add_projectile(
+            self._item_sprite, self._dynamic.tilemap.name
+        )
+        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,14 @@
+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(f"Saved the game to {self.engine.game_state.state_name}")
+
+        # print(self.engine.game_state._state["player"])

mima/scripts/commands/screen_fade.py

@@ -0,0 +1,83 @@
+from typing import Optional
+
+from ...objects.effects.colorize_screen import ColorizeScreen
+from ...util.colors import BLACK, Color
+from ..command import Command
+
+
+class CommandScreenFade(Command):
+    def __init__(
+        self,
+        duration: float = 0.5,
+        color: Optional[Color] = None,
+        fadein: bool = False,
+        map_name: Optional[str] = None,
+    ):
+        super().__init__()
+
+        self.duration: float = duration
+        if color is None:
+            color = self.engine.rtc.color_black
+
+        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._map_name = map_name
+
+        self._effect: Optional[ColorizeScreen] = None
+        # self.duration -= 0.1
+
+    def start(self):
+
+        self._effect = ColorizeScreen(
+            cameras=[
+                self.engine.get_view().get_camera_name(p) for p in self.players
+            ]
+        )
+        self._effect.alpha = self._start
+        if self._map_name is None:
+            map_names = list(
+                set(
+                    [
+                        self.engine.get_player(p).tilemap.name
+                        for p in self.players
+                    ]
+                )
+            )
+            for map_name in map_names:
+                self.engine.get_view().add_effect(self._effect, map_name)
+        else:
+            self.engine.get_view().add_effect(self._effect, self._map_name)
+        for p in self.players:
+            self.engine.get_player(p).halt()
+
+    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))
+
+        for p in self.players:
+            self.engine.get_player(p).halt()
+
+        if self.time_so_far >= self.duration:
+            self._effect.alpha = self._end
+            self.completed = True
+
+    def finalize(self):
+        self.completed = True
+        self._effect.kill()