mima-engine 0.4.0__py3-none-any.whl

mima/objects/world/pickup.py

@@ -0,0 +1,157 @@
+from typing import Optional
+
+from ...maps.tilemap import Tilemap
+from ...objects.dynamic import Dynamic
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
+from ...types.nature import Nature
+from ...types.object import ObjectType
+from ...types.terrain import Terrain
+from ...usables.item import Item
+from ...util.colors import BLACK
+from ..animated_sprite import AnimatedSprite
+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: Item,
+        *,
+        tilemap: Optional[Tilemap] = None,
+        dyn_id=0,
+    ):
+        super().__init__(
+            px,
+            py,
+            f"Pickup({item.name})",
+            sprite_name=item.sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+        )
+        self.type: ObjectType = ObjectType.PICKUP
+        self.item = item
+        # if not sprite_name:
+        #     sprite_name = self.item.sprite_name
+
+        self.collected = False
+        self.solid_vs_dyn = False
+        self.moves_on_collision = True
+        # self.sprite = AnimatedSprite(
+        #     self.item.tileset_name,
+        #     self.item.image_name,
+        #     self.item.sprite_name,
+        #     graphic_state,
+        #     facing_direction,
+        # )
+
+    def update(self, elapsed_time: float, target=None):
+        if self.collected:
+            self.kill()
+        else:
+            self._handle_terrain(elapsed_time)
+            self.sprite.update(
+                elapsed_time, self.facing_direction, self.graphic_state
+            )
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if self.collected:
+            return False
+
+        pl = target.get_player()
+        if pl.value > 0:
+            if self.item.on_interaction(target):
+                if self.engine.give_item(self.item, pl):
+                    self.collected = True
+                    return True
+            else:
+                self.collected = True
+
+        return False
+
+    def draw_self(
+        self,
+        ox: float,
+        oy: float,
+        camera_name: str = "display",
+        draw_to_ui: bool = False,
+    ):
+        if self.collected:
+            return
+
+        if self.pz != 0:
+
+            # print("Draw item circle")
+            self.engine.backend.fill_circle(
+                (self.px - ox + 0.5) * self.sprite.width,
+                (self.py - oy + 0.7) * self.sprite.height,
+                0.2875 * self.sprite.width,
+                BLACK,
+                camera_name,
+            )
+        self.sprite.draw_self(
+            self.px - ox,
+            self.py - oy - self.pz,
+            camera_name,
+            draw_to_ui=draw_to_ui,
+        )
+        # 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,
+        #     camera_name,
+        # )
+
+    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.get_view().add_effect(eff, self.tilemap.name)
+        # else:
+        #     self.attributes.speed_mod = 1.0
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
+        item = Pickup.engine.get_item(obj.get_string("usable_id"))
+
+        pickup = Pickup(
+            px,
+            py,
+            item,
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
+        )
+
+        # pickup.sprite.width = int(width * Pickup.engine.rtc.tile_width)
+        # pickup.sprite.height = int(height * Pickup.engine.rtc.tile_height)
+
+        return [pickup]

mima/objects/world/switch.py

@@ -0,0 +1,179 @@
+from typing import List, Optional, Union
+
+from ...maps.tilemap import Tilemap
+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 ..animated_sprite import AnimatedSprite
+from ..dynamic import Dynamic
+
+
+class Switch(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        name="Switch",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id=0,
+        graphic_state: GraphicState = GraphicState.OPEN,
+        initial_signal=True,
+    ):
+        if graphic_state not in [GraphicState.OPEN, GraphicState.CLOSED]:
+            msg = (
+                f"graphic_state of Switch {name}{dyn_id} must be either "
+                f" 'open' or 'closed', but it is {graphic_state.name}"
+            )
+            raise ValueError(msg)
+
+        super().__init__(
+            px,
+            py,
+            name,
+            tilemap=tilemap,
+            sprite_name=sprite_name,
+            dyn_id=dyn_id,
+        )
+
+        self.type = ObjectType.SWITCH
+        self.alignment = Alignment.NEUTRAL
+        self.graphic_state = graphic_state
+        self.signal = self.graphic_state == GraphicState.CLOSED
+        self.listener_ids: List[int] = []
+        self.listeners: List[Dynamic] = []
+        self.send_initial_signal = initial_signal
+        self.cooldown = 0.0
+        self.cooldown_reset = 0.8
+
+        # self._gs_map = {False: GraphicState.OPEN, True: GraphicState.CLOSED}
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        if self.cooldown > 0.0:
+            self.cooldown -= elapsed_time
+
+        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, camera_name: str = "display"):
+        if not self.visible:
+            # print(f"{self.name} is not visible")
+            return
+        self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        # if target.is_player().value > 0:
+        #     print(f"{target.is_player()} talked to me({self.name})")
+        if self.cooldown > 0.0:
+            return False
+
+        if (
+            nature == Nature.TALK
+            and target.type == ObjectType.PLAYER
+            and self.visible
+        ):
+            self.state_changed = True
+            self.engine.audio.play_sound("switch", 0.2)
+            self.cooldown = self.cooldown_reset
+            # print("Player talked")
+
+        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
+                    if "body" not in target.name:
+                        self.engine.audio.play_sound("switch", 0.2)
+                        self.cooldown = self.cooldown_reset
+            else:
+                # Projectiles from the left will (de)activate the switch
+                if (
+                    target.px <= self.px and target.vx > 0
+                ):  # Sword does not activate because vx=0
+                    self.state_changed = True
+                    if "body" not in target.name:
+                        self.engine.audio.play_sound("switch", 0.2)
+                        self.cooldown = self.cooldown_reset
+
+        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, tilemap):
+        switch = Switch(
+            px=px,
+            py=py,
+            name=obj.name,
+            sprite_name=obj.get_string("sprite_name"),
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
+            graphic_state=GraphicState[
+                obj.get_string("graphic_state", "closed").upper()
+            ],
+            initial_signal=obj.get_bool("initial_signal", True),
+        )
+
+        # switch.sprite.width = int(width * Switch.engine.rtc.tile_width)
+        # switch.sprite.height = int(height * Switch.engine.rtc.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,308 @@
+from __future__ import annotations
+
+import logging
+from typing import List, Optional
+
+from ...maps.tilemap import Tilemap
+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 ...types.player import Player
+from ..animated_sprite import AnimatedSprite
+from ..dynamic import Dynamic
+
+LOG = logging.getLogger(__name__)
+
+
+class Teleport(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        name="Teleport",
+        *,
+        sprite_name: str = "str",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        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,
+    ):
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=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.triggered = False
+        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
+
+        pt = target.get_player()
+        if (
+            nature == Nature.WALK
+            and pt != Player.P0
+            and not self.engine.is_teleport_active(pt)
+        ):
+            self.engine.trigger_teleport(True, pt)
+            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)
+            # self.sliding = False
+            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(
+            #             new_map_name=self.dst_map_name,
+            #             obj=target,
+            #             target_px=dst_px,
+            #             target_py=dst_py,
+            #             vx=dst_vx,
+            #             vy=dst_vy,
+            #             players=[pt],
+            #         )
+            #     )
+            # 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
+                )
+
+            cmd = CommandSerial(
+                [
+                    CommandScreenFade(),
+                    CommandParallel(
+                        [
+                            CommandChangeMap(
+                                self.dst_map_name, dst_px, dst_py
+                            ),
+                            CommandSetFacingDirection(target, new_direction),
+                            CommandScreenFade(
+                                fadein=True, map_name=self.dst_map_name
+                            ),
+                        ]
+                    ),
+                ]
+            )
+            cmd.set_players([pt])
+            self.engine.script.add_command(cmd)
+
+            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, camera_name: str = "display"):
+        if not self.visible:
+            self.engine.backend.draw_circle(
+                (self.px + 0.5 - ox) * self.engine.rtc.tile_width,
+                (self.py + 0.5 - oy) * self.engine.rtc.tile_height,
+                0.5 * self.engine.rtc.tile_width,
+                self.engine.rtc.color_red,
+                camera_name,
+            )
+            return
+
+        if self.has_sprite:
+            self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
+
+    @staticmethod
+    def load_from_tiled_object(
+        obj, px, py, width, height, tilemap
+    ) -> List[Teleport]:
+        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()
+        ]
+        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,
+                        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,
+                        tilemap=tilemap,
+                        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,
+                        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,
+                        tilemap=tilemap,
+                        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,
+                    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,
+                    tilemap=tilemap,
+                    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/scripts/__init__.py

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

mima/scripts/command.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional
+
+from ..types.player import Player
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+
+
+class Command:
+    engine: MimaEngine
+
+    def __init__(self, players: Optional[List[Player]] = None):
+        self.started: bool = False
+        self.completed: bool = False
+        self.uninterruptible: bool = False
+        self.players: List[Player] = (
+            players if (players is not None and players) else [Player.P0]
+        )
+
+    def start(self):
+        pass
+
+    def update(self, elapsed_time: float):
+        pass
+
+    def can_complete(self, force: bool = False) -> bool:
+        if self.uninterruptible and not force:
+            return False
+
+        return True
+
+    def finalize(self):
+        pass
+
+    def set_players(self, players: List[Player]):
+        self.players = players