mima-engine 0.4.0__py3-none-any.whl

mima/objects/sprite.py

@@ -0,0 +1,116 @@
+from ..types.direction import Direction
+from ..types.graphic_state import GraphicState
+from ..util.constants import (
+    DEFAULT_GRAPHIC_TIMER,
+    DEFAULT_GRAPHIC_TIMER_DAMAGED,
+    DEFAULT_GRAPHIC_TIMER_DEAD,
+    DEFAULT_GRAPHIC_TIMER_STANDING,
+    DEFAULT_GRAPHIC_TIMER_WALKING,
+    DEFAULT_SPRITE_HEIGHT,
+    DEFAULT_SPRITE_WIDTH,
+)
+
+
+class Sprite:
+    engine = None
+
+    def __init__(self, name: str = "", *, ox=0, oy=0, width=0, height=0):
+        self.name = name
+        self.ox: int = 0
+        self.oy: int = 0
+        self.width: int = DEFAULT_SPRITE_WIDTH if width == 0 else width
+        self.height: int = DEFAULT_SPRITE_HEIGHT if height == 0 else height
+        self.num_frames: int = 1
+        self.frame_index: int = 0
+
+        self.timer: float = 0.25
+        self.timer_reset: float = 0.5
+
+        self.last_direction: Direction = Direction.SOUTH
+        self.last_graphic_state: GraphicState = GraphicState.STANDING
+
+    def update(
+        self,
+        elapsed_time: float,
+        direction: Direction = Direction.SOUTH,
+        graphic_state: GraphicState = GraphicState.STANDING,
+    ):
+        if (
+            direction == self.last_direction
+            and graphic_state == self.last_graphic_state
+        ):
+            # Nothing has changed, normal case
+            self.timer -= elapsed_time
+
+            if self.timer <= 0.0:
+                self.timer += self.timer_reset
+                self.frame_index = (self.frame_index + 1) % self.num_frames
+
+        else:
+            # Something changed
+            if graphic_state != self.last_graphic_state:
+                # State changed
+                if graphic_state == GraphicState.STANDING:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_STANDING
+                elif graphic_state == GraphicState.WALKING:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_WALKING
+                elif graphic_state == GraphicState.DAMAGED:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_DAMAGED
+                elif graphic_state == GraphicState.DEAD:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_DEAD
+                elif graphic_state == GraphicState.PUSHING:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_WALKING
+                else:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER
+
+                # self.timer = self.timer_reset
+                # self.frame_index = 0
+
+            self.timer = self.timer_reset
+            self.frame_index = 0
+
+        self.last_direction = direction
+        self.last_graphic_state = graphic_state
+
+    def draw_self(
+        self,
+        px: float,
+        py: float,
+        camera_name: str = "display",
+        draw_to_ui: bool = False,
+    ):
+        if self.name == "":
+            return
+
+        sheet_ox = sheet_oy = 0
+        state_value = self.last_graphic_state.value
+
+        if self.last_graphic_state == GraphicState.CELEBRATING:
+            sheet_ox = (self.ox + self.frame_index) * self.width
+            sheet_oy = (self.oy + state_value) * self.height
+        elif self.last_graphic_state == GraphicState.DEAD:
+            sheet_ox = (self.ox + 2 + self.frame_index) * self.width
+            sheet_oy = (self.oy + state_value) * self.height
+        else:
+            if self.last_graphic_state == GraphicState.PUSHING:
+                state_value -= 1
+            sheet_ox = (
+                self.ox + 2 * self.last_direction.value + self.frame_index
+            ) * self.width
+            sheet_oy = (self.oy + state_value) * self.height
+
+        self.engine.backend.draw_partial_sprite(
+            px * self.engine.rtc.tile_width,
+            py * self.engine.rtc.tile_height,
+            self.name,
+            sheet_ox,
+            sheet_oy,
+            self.width,
+            self.height,
+            camera_name,
+            draw_to_ui=draw_to_ui,
+        )
+
+    def reset(self):
+        self.frame_index = 0
+        self.timer = 0.0

mima/objects/world/color_gate.py

@@ -0,0 +1,67 @@
+from typing import List, Optional, Union
+
+from ...maps.tilemap import Tilemap
+from ...types.direction import Direction
+from ...types.gate_color import GateColor
+from ...types.graphic_state import GraphicState
+from ...types.nature import Nature
+from ...types.object import ObjectType
+from ..dynamic import Dynamic
+from .gate import Gate
+
+
+class ColorGate(Gate):
+
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        name: str = "ColorGate",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        graphic_state: GraphicState = GraphicState.STANDING,
+        facing_direction: Direction = Direction.SOUTH,
+        color: GateColor = GateColor.RED,
+    ):
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+            graphic_state=graphic_state,
+            facing_direction=facing_direction,
+            bombable=False,
+        )
+        self.color = color
+        self.type = ObjectType.COLOR_GATE
+
+    def update(self, elapsed_time, float, target: Optional[Dynamic] = None):
+        self.open = self.engine.gate_color == self.color
+        super().update(elapsed_time, target)
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        return False
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
+        gate = ColorGate(
+            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()
+            ],
+            facing_direction=Direction[
+                obj.get_string("facing_direction", "south").upper()
+            ],
+            color=GateColor[obj.get_string("color", "red").upper()],
+        )
+
+        return [gate]

mima/objects/world/color_switch.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Optional, Union
+
+from ...types.direction import Direction
+from ...types.gate_color import GateColor
+from ...types.graphic_state import GraphicState
+from ...types.nature import Nature
+from ...types.object import ObjectType
+from ..dynamic import Dynamic
+from .switch import Switch
+
+if TYPE_CHECKING:
+    from ...maps.tilemap import Tilemap
+
+
+class ColorSwitch(Switch):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        name="ColorSwitch",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id=-1,
+        graphic_state: GraphicState = GraphicState.OPEN,
+        initial_signal=False,
+        color: GateColor = GateColor.RED,
+    ):
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+            graphic_state=graphic_state,
+            initial_signal=initial_signal,
+        )
+        self.type = ObjectType.COLOR_SWITCH
+
+        self.color = color
+        self.graphic_state = (
+            GraphicState.CLOSED
+            if color == self.engine.gate_color
+            else GraphicState.OPEN
+        )
+        # self.signal = self.graphic_state == GraphicState.CLOSED
+        # self.send_initial_signal = False
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        self.graphic_state = (
+            GraphicState.CLOSED
+            if self.color == self.engine.gate_color
+            else GraphicState.OPEN
+        )
+        # self.signal = self.graphic_state == GraphicState.CLOSED
+        #
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if (
+            nature == Nature.TALK
+            and target.type == ObjectType.PLAYER
+            and self.visible
+        ):
+            if self.engine.gate_color != self.color:
+                self.engine.gate_color = self.color
+            else:
+                self.engine.gate_color = GateColor(
+                    (self.color.value + 1) % self.engine.n_gate_colors
+                )
+            self.state_changed = True
+            self.engine.audio.play_sound("switch")
+            return True
+
+        return False
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
+        switch = ColorSwitch(
+            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()
+            ],
+            color=GateColor[obj.get_string("color", "red").upper()],
+            initial_signal=False,
+        )
+
+        # switch.sprite.width = int(width * ColorSwitch.engine.rtc.tile_width)
+        # switch.sprite.height = int(height * ColorSwitch.engine.rtc.tile_height)
+
+        return [switch]

mima/objects/world/container.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import logging
+from typing import List, Optional
+
+from ...maps.tilemap import Tilemap
+from ...scripts.commands.give_item import CommandGiveItem
+from ...scripts.commands.give_resource import CommandGiveResource
+from ...scripts.commands.parallel import CommandParallel
+from ...scripts.commands.present_item import CommandPresentItem
+from ...scripts.commands.show_dialog import CommandShowDialog
+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
+
+LOG = logging.getLogger(__name__)
+
+
+class Container(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        name: str = "Container",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        graphic_state: GraphicState = GraphicState.CLOSED,
+        item_name: str = "",
+    ):
+        if graphic_state not in [
+            GraphicState.OPEN,
+            GraphicState.CLOSED,
+        ]:
+            msg = (
+                f"graphic_state of Container {name}{dyn_id} must be either "
+                f"'open' or 'closed', but it is {graphic_state}"
+            )
+            raise ValueError(msg)
+        super().__init__(
+            px,
+            py,
+            name,
+            tilemap=tilemap,
+            sprite_name=sprite_name,
+            dyn_id=dyn_id,
+        )
+
+        self.type = ObjectType.CONTAINER
+        self.graphic_state = graphic_state
+        self.closed: bool = self.graphic_state != GraphicState.OPEN
+
+        self.item_name: str = item_name
+        self.item = self.engine.get_item(item_name)
+        self.solid_vs_dyn: bool = True
+        self.solid_vs_map: bool = True
+        self.visible: bool = True
+
+        self.is_resource: bool = False
+        self.amount: int = 1
+
+        self._gs_map = {False: GraphicState.OPEN, True: GraphicState.CLOSED}
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        if self.visible:
+            self.solid_vs_dyn = True
+        else:
+            self.solid_vs_dyn = False
+
+        self.graphic_state = (
+            GraphicState.CLOSED if self.closed 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:
+            return
+
+        self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
+
+    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 not self.visible:
+            return False
+
+        if nature == Nature.TALK:
+            if self.closed:
+                if self.is_resource:
+                    text = "You received "
+                    if self.amount > 1:
+                        text += f"{self.amount} {self.item.name}s!"
+                    elif self.amount == 1:
+                        text += f"one {self.item.name}!"
+                    else:
+                        text += "nothing. The chest was empty!"
+
+                    if self.item_name == "coin":
+                        cgr = CommandGiveResource(target, coins=self.amount)
+                    elif self.item_name == "bomb_refill":
+                        cgr = CommandGiveResource(target, bombs=self.amount)
+                    elif self.item_name == "arrow_refill":
+                        cgr = CommandGiveResource(target, arrows=self.amount)
+                    elif self.item_name == "key":
+                        cgr = CommandGiveResource(target, keys=self.amount)
+                    else:
+                        LOG.error(f"Invalid resource type: {self.item_name}")
+                        return False
+
+                    self.engine.script.add_command(
+                        CommandParallel(
+                            [
+                                CommandShowDialog([text]),
+                                CommandPresentItem(self.item_name, target),
+                                cgr,
+                            ],
+                            CommandParallel.FIRST_COMPLETED,
+                        ),
+                        players=[target.get_player()],
+                    )
+
+                else:
+
+                    self.engine.script.add_command(
+                        CommandParallel(
+                            [
+                                CommandShowDialog(
+                                    [f"You received {self.item.name}"],
+                                ),
+                                CommandPresentItem(self.item_name, target),
+                                CommandGiveItem(self.item_name, target),
+                            ],
+                            CommandParallel.FIRST_COMPLETED,
+                        ),
+                        players=[target.get_player()],
+                    )
+                self.closed = False
+                self.state_changed = True
+                return True
+
+        return False
+
+    @staticmethod
+    def load_from_tiled_object(
+        obj, px, py, width, height, tilemap
+    ) -> List[Container]:
+        container = Container(
+            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()
+            ],
+            item_name=obj.get_string("item_name"),
+        )
+        container.is_resource = obj.get_bool("is_resource", False)
+        container.amount = obj.get_int("amount", 1)
+
+        return [container]

mima/objects/world/floor_switch.py

@@ -0,0 +1,109 @@
+from typing import Optional
+
+from ...maps.tilemap import Tilemap
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
+from ...types.nature import Nature
+from ...types.object import ObjectType
+from ..dynamic import Dynamic
+from .switch import Switch
+
+
+class FloorSwitch(Switch):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        name="Floor Switch",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        graphic_state: GraphicState = GraphicState.OPEN,
+        initial_signal: bool = True,
+    ):
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+            graphic_state=graphic_state,
+            initial_signal=initial_signal,
+        )
+        self.layer = 0
+
+        self.type = ObjectType.FLOOR_SWITCH
+        self.interacted = False
+        self.interacted_before = False
+        self.solid_vs_dyn = False
+
+    def update(self, elapsed_time: float, target: Dynamic):
+        if self.send_initial_signal:
+            self.send_signal(self.signal)
+            self.send_initial_signal = False
+        self.state_changed = False
+        if not self.interacted:
+            if self.interacted_before:
+                self.state_changed = True
+            self.interacted_before = False
+
+        else:
+            if not self.interacted_before:
+                self.state_changed = True
+            self.interacted_before = True
+
+        self.interacted = False
+
+        if self.state_changed:
+            self.signal = not self.signal
+            self.send_signal(self.signal)
+
+        self.graphic_state = (
+            GraphicState.CLOSED if self.signal else GraphicState.OPEN
+        )
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if nature == Nature.WALK and not target.type == ObjectType.PROJECTILE:
+            if target.type == ObjectType.MOVABLE:
+                if not target.visible:
+                    return False
+            self.interacted = True
+            return True
+
+        return False
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
+        fswitch = FloorSwitch(
+            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),
+        )
+        # TODO: Why was this used?
+        # fswitch.sprite.width = int(width * FloorSwitch.engine.rtc.tile_width)
+        # fswitch.sprite.height = int(
+        #     height * FloorSwitch.engine.rtc.tile_height
+        # )
+
+        ctr = 1
+        while True:
+            key = f"output{ctr}"
+            listener_id = obj.get_int(key, -1)
+            if listener_id < 0:
+                break
+            fswitch.listener_ids.append(listener_id)
+            ctr += 1
+
+        return [fswitch]