mima-engine 0.1.0__py3-none-any.whl

mima/objects/world/pickup.py

@@ -0,0 +1,88 @@
+from ...objects.dynamic import Dynamic
+from ...types.nature import Nature
+from ...types.object import ObjectType
+from ...types.terrain import Terrain
+from ...util.colors import BLACK
+from ..effects.walking_on_grass import WalkingOnGrass
+from ..effects.walking_on_water import WalkingOnWater
+
+
+class Pickup(Dynamic):
+    def __init__(self, px: float, py: float, item_name: str, dyn_id=-1):
+        super().__init__("Pickup", px, py, dyn_id)
+        self.type: ObjectType = ObjectType.PICKUP
+        self.item = self.engine.get_item(item_name)
+        self.collected = False
+        self.solid_vs_dyn = False
+
+    def update(self, elapsed_time: float, target=None):
+        if self.collected:
+            self.kill()
+        else:
+            self._handle_terrain(elapsed_time)
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if self.collected:
+            return False
+
+        if target.type == ObjectType.PLAYER:
+            if self.item.on_interaction(target):
+                if self.engine.give_item(self.item):
+                    self.collected = True
+                    return True
+            else:
+                self.collected = True
+
+        return False
+
+    def draw_self(self, ox: float, oy: float):
+        if self.collected:
+            return
+
+        if self.pz != 0:
+            self.engine.backend.fill_circle(
+                (self.px - ox + 0.5) * self.item.sprite_width,
+                (self.py - oy + 0.7) * self.item.sprite_height,
+                0.2875 * self.item.sprite_width,
+                BLACK,
+            )
+
+        self.engine.backend.draw_partial_sprite(
+            (self.px - ox) * self.item.sprite_width,
+            (self.py - oy - self.pz) * self.item.sprite_height,
+            self.item.sprite_name,
+            self.item.sprite_ox * self.item.sprite_width,
+            self.item.sprite_oy * self.item.sprite_height,
+            self.item.sprite_width,
+            self.item.sprite_height,
+        )
+
+    def _handle_terrain(self, elapsed_time: float):
+        """Method is duplicated."""
+        e2rm = []
+        for effect in self.effects:
+            if isinstance(effect, WalkingOnGrass):
+                if self.walking_on == Terrain.DEFAULT:
+                    e2rm.append(effect)
+
+        for effect in e2rm:
+            self.effects.remove(effect)
+
+        if self.walking_on in [Terrain.GRASS, Terrain.SHALLOW_WATER]:
+            # self.attributes.speed_mod = 0.7
+            effect_active = False
+            for effect in self.effects:
+                if isinstance(effect, (WalkingOnGrass, WalkingOnWater)):
+                    effect_active = True
+                    effect.renew = True
+                    break
+
+            if not effect_active:
+                if self.walking_on == Terrain.GRASS:
+                    eff = WalkingOnGrass(self)
+                else:
+                    eff = WalkingOnWater(self)
+                self.effects.append(eff)
+                self.engine.scene.add_effect(eff)
+        # else:
+        #     self.attributes.speed_mod = 1.0

mima/objects/world/switch.py

@@ -0,0 +1,165 @@
+from typing import List, Optional, Union
+
+from ...types.alignment import Alignment
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
+from ...types.nature import Nature
+from ...types.object import ObjectType
+from ...util.constants import TILE_HEIGHT, TILE_WIDTH
+from ..animated_sprite import AnimatedSprite
+from ..dynamic import Dynamic
+
+
+class Switch(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        facing_direction: Direction,
+        graphic_state: GraphicState,
+        initial_signal=True,
+        dyn_id=-1,
+        name="Switch",
+    ):
+        assert graphic_state in [GraphicState.OPEN, GraphicState.CLOSED], (
+            f"graphic_state of Switch {name}{dyn_id} must be either 'open'"
+            f" or 'closed', but it {graphic_state}"
+        )
+        super().__init__(name, px, py, dyn_id)
+
+        self.sprite = AnimatedSprite(
+            tileset_name,
+            image_name,
+            sprite_name,
+            graphic_state,
+            facing_direction,
+        )
+
+        self.type = ObjectType.SWITCH
+        self.alignment = Alignment.NEUTRAL
+        self.graphic_state = graphic_state
+        self.facing_direction = facing_direction
+        self.signal = self.graphic_state == GraphicState.CLOSED
+        self.listener_ids: List[int] = []
+        self.listeners: List[Dynamic] = []
+        self.send_initial_signal = initial_signal
+
+        # self._gs_map = {False: GraphicState.OPEN, True: GraphicState.CLOSED}
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        if self.send_initial_signal:
+            self.send_signal(self.signal)
+            self.send_initial_signal = False
+
+        self.solid_vs_dyn = self.visible
+        self.graphic_state = (
+            GraphicState.CLOSED if self.signal else GraphicState.OPEN
+        )
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+    def draw_self(self, ox: float, oy: float):
+        if not self.visible:
+            # print(f"{self.name} is not visible")
+            return
+        self.sprite.draw_self(self.px - ox, self.py - oy)
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if (
+            nature == Nature.TALK
+            and target.type == ObjectType.PLAYER
+            and self.visible
+        ):
+            self.state_changed = True
+            self.engine.audio.play_sound("switch")
+
+        elif nature == Nature.WALK and target.type == ObjectType.PROJECTILE:
+            if self.signal:
+                # Projectiles from the right will activate the switch
+                if target.px > self.px and target.vx < 0:
+                    self.state_changed = True
+            else:
+                # Projectiles from the left will (de)activate the switch
+                if target.px <= self.px and target.vx > 0:
+                    self.state_changed = True
+            if "body" not in target.name:
+                self.engine.audio.play_sound("switch")
+
+        elif nature == Nature.SIGNAL:
+            self.visible = False
+            return True
+
+        elif nature == Nature.NO_SIGNAL:
+            self.visible = True
+            return True
+
+        if self.state_changed:
+            self.signal = not self.signal
+            self.send_signal(self.signal)
+
+            if target.type == ObjectType.PROJECTILE:
+                target.kill()
+            return True
+        return False
+
+    def send_signal(self, nature: Union[Nature, bool]):
+        if isinstance(nature, bool):
+            nature = Nature.SIGNAL if nature else Nature.NO_SIGNAL
+
+        for listener in self.listeners:
+            listener.on_interaction(self, nature)
+
+        if (
+            not self.send_initial_signal
+            and abs(self.engine.player.px - self.px)
+            < (self.engine.backend.render_width // (TILE_WIDTH * 2))
+            and abs(self.engine.player.py - self.py)
+            < (self.engine.backend.render_height // (TILE_HEIGHT * 2))
+        ):
+            print(
+                (
+                    self.engine.player.px - self.px,
+                    self.engine.player.py - self.py,
+                ),
+                (
+                    self.engine.backend.render_width // (TILE_WIDTH * 2),
+                    self.engine.backend.render_height // (TILE_HEIGHT * 2),
+                ),
+            )
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height):
+        switch = Switch(
+            px=px,
+            py=py,
+            tileset_name=obj.get_string("tileset_name"),
+            image_name=obj.get_string("tileset_name"),
+            sprite_name=obj.get_string("sprite_name"),
+            graphic_state=GraphicState[
+                obj.get_string("graphic_state", "closed").upper()
+            ],
+            facing_direction=Direction[
+                obj.get_string("facing_direction", "south").upper()
+            ],
+            initial_signal=obj.get_bool("initial_signal", True),
+            dyn_id=obj.object_id,
+            name=obj.name,
+        )
+
+        switch.sprite.width = int(width * TILE_WIDTH)
+        switch.sprite.height = int(height * TILE_HEIGHT)
+
+        ctr = 1
+        while True:
+            key = f"output{ctr}"
+            listener_id = obj.get_int(key, -1)
+            if listener_id < 0:
+                break
+            switch.listener_ids.append(listener_id)
+            ctr += 1
+
+        return [switch]

mima/objects/world/teleport.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+import logging
+from typing import List, Optional
+
+from ...scripts.commands.change_map import CommandChangeMap
+from ...scripts.commands.move_map import CommandMoveMap
+from ...scripts.commands.parallel import CommandParallel
+from ...scripts.commands.screen_fade import CommandScreenFade
+from ...scripts.commands.serial import CommandSerial
+from ...scripts.commands.set_facing_direction import CommandSetFacingDirection
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
+from ...types.nature import Nature
+from ...types.object import ObjectType
+from ...util.colors import RED
+from ...util.constants import TILE_HEIGHT, TILE_WIDTH
+from ..animated_sprite import AnimatedSprite
+from ..dynamic import Dynamic
+
+LOG = logging.getLogger(__name__)
+
+
+class Teleport(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        facing_direction: Direction,
+        graphic_state: GraphicState,
+        dst_map_name: str,
+        dst_px: float,
+        dst_py: float,
+        direction: Direction,
+        invert_exit_direction: bool = False,
+        relative: bool = False,
+        sliding: bool = False,
+        vertical: bool = False,
+        dyn_id: int = -1,
+        name="Teleport",
+    ):
+        super().__init__(name, px, py, dyn_id)
+
+        self.sprite = AnimatedSprite(
+            tileset_name, image_name, sprite_name, graphic_state, facing_direction
+        )
+
+        self.type = ObjectType.TELEPORT
+        self.graphic_state = graphic_state
+        self.facing_direction = facing_direction
+        self.solid_vs_dyn = False
+        self.solid_vs_map = False
+
+        self.dst_px: float = dst_px
+        self.dst_py: float = dst_py
+        self.dst_map_name: str = dst_map_name
+        self.has_sprite = self.sprite.name != ""
+        self.teleport_direction: Direction = direction
+
+        self.visible = True
+        self.invert_exit_direction = invert_exit_direction
+        self.relative = relative
+        self.sliding = sliding
+        self.vertical = vertical
+        self.triggered = False
+        self.sfx_on_trigger: str = ""
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        self.sprite.update(elapsed_time, self.facing_direction, self.graphic_state)
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if nature == Nature.SIGNAL:
+            self.visible = True
+            return True
+        if nature == Nature.NO_SIGNAL:
+            self.visible = False
+            return True
+
+        if self.has_sprite and not self.visible:
+            return False
+
+        if (
+            nature == Nature.WALK
+            and target.type == ObjectType.PLAYER
+            and not self.engine.teleport_triggered
+        ):
+            self.engine.teleport_triggered = True
+            dst_px = self.dst_px
+            dst_py = self.dst_py
+            dst_vx = 0
+            dst_vy = 0
+
+            dst_vx, dst_vy = Direction.to_velocity(self.teleport_direction)
+
+            # if self.relative:
+            #     if self.vertical:
+            #         dst_py += target.py
+            #     else:
+            #         dst_px += target.px
+
+            if self.sliding:
+                if dst_vx != 0:
+                    dst_py = target.py
+                elif dst_vy != 0:
+                    dst_px = target.px
+
+                self.engine.script.add_command(
+                    CommandMoveMap(
+                        self.dst_map_name,
+                        target,
+                        dst_px,
+                        dst_py,
+                        dst_vx,
+                        dst_vy,
+                    )
+                )
+            else:
+                if self.triggered:
+                    return False
+
+                new_direction = target.facing_direction
+                if self.invert_exit_direction:
+                    new_direction = Direction((target.facing_direction.value + 2) % 4)
+
+                self.engine.script.add_command(
+                    CommandSerial(
+                        [
+                            CommandScreenFade(),
+                            CommandParallel(
+                                [
+                                    CommandChangeMap(self.dst_map_name, dst_px, dst_py),
+                                    CommandSetFacingDirection(target, new_direction),
+                                    CommandScreenFade(fadein=True),
+                                ]
+                            ),
+                        ],
+                    )
+                )
+                if self.sfx_on_trigger:
+                    self.engine.audio.play_sound(self.sfx_on_trigger)
+
+                self.triggered = True
+            return True
+
+        return False
+
+    def draw_self(self, ox: float, oy: float):
+        if not self.visible:
+            self.engine.backend.draw_circle(
+                (self.px + 0.5 - ox) * TILE_WIDTH,
+                (self.py + 0.5 - oy) * TILE_HEIGHT,
+                0.5 * TILE_WIDTH,
+                RED,
+            )
+            return
+
+        if self.has_sprite:
+            self.sprite.draw_self(self.px - ox, self.py - oy)
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height) -> List[Teleport]:
+        sprite_name = obj.get_string("sprite_name")
+        tileset_name = obj.get_string("tileset_name")
+        image_name = obj.get_string("tileset_name")
+        graphic_state = GraphicState[obj.get_string("graphic_state", "closed").upper()]
+        facing_direction = Direction[obj.get_string("facing_direction", "south").upper()]
+        target_map = obj.get_string("target_map", "map1_c1")
+        invert_exit_direction = obj.get_bool("invert_exit_direction")
+        relative = obj.get_bool("relative", False)
+        sliding = obj.get_bool("sliding", False)
+        vertical = obj.get_bool("vertical", False)
+        layer = obj.get_int("layer", 1)
+        target_px = obj.get_float("target_px")
+        target_py = obj.get_float("target_py")
+        direction = Direction[obj.get_string("direction", "south").upper()]
+        teleports = []
+        if width > height and int(width) > 1:
+            num_horizontal = int(width)
+            for idx in range(num_horizontal):
+                from_px = px + idx
+                from_py = py
+                to_px = target_px + idx
+                to_py = target_py
+
+                LOG.debug(
+                    "Adding a teleport at (%f, %f) to map %s (%f, %f).",
+                    from_px,
+                    from_py,
+                    target_map,
+                    to_px,
+                    to_py,
+                )
+                teleports.append(
+                    Teleport(
+                        px=from_px,
+                        py=from_py,
+                        tileset_name=tileset_name,
+                        image_name=image_name,
+                        sprite_name=sprite_name,
+                        graphic_state=graphic_state,
+                        facing_direction=facing_direction,
+                        dst_map_name=target_map,
+                        dst_px=to_px,
+                        dst_py=to_py,
+                        direction=direction,
+                        invert_exit_direction=invert_exit_direction,
+                        relative=relative,
+                        sliding=sliding,
+                        vertical=False,
+                        dyn_id=obj.object_id,
+                        name=obj.name,
+                    )
+                )
+                teleports[-1].layer = layer
+        elif height > width and int(height) > 1:
+            num_vertical = int(height)
+            for idx in range(num_vertical):
+                from_px = px
+                from_py = py + idx
+                to_px = target_px
+                to_py = target_py if relative else from_py
+
+                LOG.debug(
+                    "Adding a teleport at (%f, %f) to map %s (%f, %f).",
+                    from_px,
+                    from_py,
+                    target_map,
+                    to_px,
+                    to_py,
+                )
+                teleports.append(
+                    Teleport(
+                        px=from_px,
+                        py=from_py,
+                        tileset_name=tileset_name,
+                        image_name=image_name,
+                        sprite_name=sprite_name,
+                        graphic_state=graphic_state,
+                        facing_direction=facing_direction,
+                        dst_map_name=target_map,
+                        dst_px=to_px,
+                        dst_py=to_py,
+                        direction=direction,
+                        invert_exit_direction=invert_exit_direction,
+                        relative=relative,
+                        sliding=sliding,
+                        vertical=True,
+                        dyn_id=obj.object_id,
+                        name=obj.name,
+                    )
+                )
+                teleports[-1].layer = layer
+        else:
+            LOG.debug(
+                "Adding a teleport at (%f, %f) to map %s (%f, %f).",
+                px,
+                py,
+                target_map,
+                target_px,
+                target_py,
+            )
+            teleports.append(
+                Teleport(
+                    px=px,
+                    py=py,
+                    tileset_name=tileset_name,
+                    image_name=image_name,
+                    sprite_name=sprite_name,
+                    graphic_state=graphic_state,
+                    facing_direction=facing_direction,
+                    dst_map_name=target_map,
+                    dst_px=target_px,
+                    dst_py=target_py,
+                    direction=direction,
+                    invert_exit_direction=invert_exit_direction,
+                    relative=relative,
+                    sliding=sliding,
+                    vertical=vertical,
+                    dyn_id=obj.object_id,
+                    name=obj.name,
+                )
+            )
+            teleports[-1].sfx_on_trigger = obj.get_string("sfx_name")
+            teleports[-1].layer = layer
+
+        return teleports

mima/scene_engine.py

@@ -0,0 +1,79 @@
+from typing import TYPE_CHECKING, Dict, List, Optional, Union
+
+from .engine import MimaEngine
+from .states.game_state import GameState
+from .types.keys import Key as K
+from .types.nature import Nature
+from .view.scene import Scene
+from .types.mode import Mode
+
+
+class MimaSceneEngine(MimaEngine):
+    def __init__(
+        self, init_file: str, platform: str = "PC", caption: str = "MimaEngine"
+    ):
+        super().__init__(init_file, platform, caption)
+
+        self.scene_stack: List[str] = []
+        self._scenes: Dict[str, Scene] = {}
+        self._current_scene: Scene
+
+        self.all_games: Dict[str, GameState] = {}
+        self.current_game: str = ""
+        self.save_timer_reset = 1.0
+        self._save_timer = self.save_timer_reset
+        self.teleport_triggered: bool = False
+        self.dialog_active: bool = False
+
+    def on_user_create(self):
+        return True
+
+    def on_user_update(self, elapsed_time: float):
+        self.audio.update(elapsed_time)
+        self._current_scene = self._scenes[self.scene_stack[-1]]
+
+        # self._current_scene = self.mode.name.lower()
+
+        self._save_timer -= elapsed_time
+        if self._save_timer <= 0.0:
+            self._save_timer += self.save_timer_reset
+            if self._current_scene.autosave:
+                for quest in self.quests:
+                    for obj in self.scene.dynamics:
+                        quest.on_interaction(
+                            self.scene.dynamics, obj, Nature.SAVE
+                        )
+                    quest.save_state()
+        if self.keys.new_key_press(K.SELECT):
+            self.game_state.save_to_disk()
+
+        self.scene.update(elapsed_time)
+
+        return True
+
+    def change_map(self, map_name: str, px: float, py: float):
+        type_string = (
+            self.get_map(map_name).get_string("type", "local").upper()
+        )
+        if type_string == "WORLD":
+            type_string = "WORLD_MAP"
+        if type_string == "LOCAL":
+            type_string = "LOCAL_MAP"
+        mode = Mode[type_string]
+
+        self.scene_stack.append(mode)
+        self._scenes[self.scene_stack[-1]].change_map(map_name, px, py)
+        # print(self.scene_stack)
+
+    @property
+    def scene(self) -> Scene:
+        # return self._scenes[self._current_scene]
+        return self._current_scene
+
+    @property
+    def previous_scene(self) -> Scene:
+        return self._scenes[self.scene_stack[-2]]
+
+    @property
+    def game_state(self) -> GameState:
+        return self.all_games[self.current_game]

mima/scripts/__init__.py

@@ -0,0 +1,2 @@
+from .command import Command
+from .script_processor import ScriptProcessor

mima/scripts/command.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+
+
+class Command:
+    engine: MimaEngine
+
+    def __init__(self):
+        self.started: bool = False
+        self.completed: bool = False
+        self.uninterruptible: bool = False
+
+    def start(self):
+        pass
+
+    def update(self, elapsed_time: float):
+        pass
+
+    def finalize(self):
+        pass

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,15 @@
+from ..command import Command
+
+
+class CommandChangeMap(Command):
+    def __init__(self, map_name: str, spawn_px: float, spawn_py):
+        super().__init__()
+
+        self._map_name: str = map_name
+        self._spawn_px: float = spawn_px
+        self._spawn_py: float = spawn_py
+
+    def start(self):
+        self.engine.scene_stack.pop()
+        self.engine.change_map(self._map_name, self._spawn_px, self._spawn_py)
+        self.completed = True

mima/scripts/commands/close_dialog.py

@@ -0,0 +1,8 @@
+from ..command import Command
+
+
+class CommandCloseDialog(Command):
+    def start(self):
+        self.engine.dialog_active = False
+        self.engine.exit_dialog_active = False
+        self.completed = True