mima-engine 0.1.0__py3-none-any.whl

mima/objects/world/container.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+from typing import List, Optional
+
+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
+
+
+class Container(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        graphic_state: GraphicState,
+        facing_direction: Direction,
+        item_name: str,
+        dyn_id: int = -1,
+        name: str = "Container",
+    ):
+        assert graphic_state in [
+            GraphicState.OPEN,
+            GraphicState.CLOSED,
+        ], (
+            f"graphic_state of Container {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.CONTAINER
+        self.graphic_state = graphic_state
+        self.facing_direction = facing_direction
+        self.closed: bool = self.graphic_state != GraphicState.OPEN
+
+        self.item_name: str = 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.sprite = AnimatedSprite("simple_sheet", "simple_sheet", "chest01")
+        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):
+        if not self.visible:
+            return
+
+        self.sprite.draw_self(self.px - ox, self.py - oy)
+
+    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:
+                        print(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,
+                        )
+                    )
+
+                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,
+                        )
+                    )
+                self.closed = False
+                self.state_changed = True
+                return True
+
+        return False
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height) -> List[Container]:
+        container = Container(
+            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()
+            ],
+            item_name=obj.get_string("item_name"),
+            dyn_id=obj.object_id,
+            name=obj.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,111 @@
+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 ..dynamic import Dynamic
+from .switch import Switch
+
+
+class FloorSwitch(Switch):
+    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="Floor Switch",
+    ):
+        super().__init__(
+            px,
+            py,
+            tileset_name,
+            image_name,
+            sprite_name,
+            facing_direction,
+            graphic_state,
+            initial_signal,
+            dyn_id,
+            name,
+        )
+        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):
+        fswitch = FloorSwitch(
+            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,
+        )
+        fswitch.sprite.width = int(width * TILE_WIDTH)
+        fswitch.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
+            fswitch.listener_ids.append(listener_id)
+            ctr += 1
+
+        return [fswitch]

mima/objects/world/gate.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+from ...types.damage import Damage
+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
+from .teleport import Teleport
+
+
+class Gate(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        graphic_state: GraphicState,
+        facing_direction: Direction,
+        bombable: bool = False,
+        dyn_id: int = -1,
+        name: str = "Gate",
+    ):
+        assert graphic_state in [
+            GraphicState.OPEN,
+            GraphicState.CLOSED,
+            GraphicState.LOCKED,
+        ], (
+            f"graphic_state of Gate {name}{dyn_id} must be either 'open'"
+            f", 'closed', or 'locked', 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.GATE
+
+        self.graphic_state = graphic_state
+        self.facing_direction = facing_direction
+        self.open = self.graphic_state == GraphicState.OPEN
+
+        # self.closed_sprite_name = closed_sprite_name
+        # self.open_sprite_name = open_sprite_name
+        # self.closed_sprite_ox: float = closed_sprite_ox
+        # self.closed_sprite_oy: float = closed_sprite_oy
+        # self.open_sprite_ox: float = open_sprite_ox
+        # self.open_sprite_oy: float = open_sprite_oy
+
+        # self.open = open
+        self.bombable = bombable
+        self.requires_key = self.graphic_state == GraphicState.LOCKED
+        self.unlocked = False
+        self.solid_vs_map = False
+        self.layer = 0
+        self.hitbox_px = self.hitbox_py = 0.0
+        self.hitbox_width = self.hitbox_height = 1.0
+        # self._set_sprite_state()
+
+    def update(self, elapsed_time: float, target: Dynamic):
+        self.solid_vs_dyn = not self.open
+        self.graphic_state = (
+            GraphicState.OPEN
+            if self.open
+            else (
+                GraphicState.LOCKED
+                if self.requires_key
+                else 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:
+            if target.type == ObjectType.PLAYER:
+                if (
+                    not self.open
+                    and self.requires_key
+                    and target.attributes.keys > 0
+                ):
+                    target.attributes.keys -= 1
+                    self.open = True
+                    self.state_changed = True
+                    self.unlocked = True
+                    return True
+
+        if nature == Nature.SIGNAL:
+            self.open = True
+            self.state_changed = True
+            return True
+
+        if nature == Nature.NO_SIGNAL and not self.unlocked:
+            self.open = False
+            self.state_changed = True
+            return True
+
+        if self.bombable and target.type == ObjectType.PROJECTILE:
+            if target.dtype == Damage.EXPLOSION:
+                self.open = True
+                self.state_changed = True
+                if target.one_hit:
+                    target.kill()
+
+        return False
+
+    def draw_self(self, ox: float, oy: float):
+        self.sprite.draw_self(self.px - ox, self.py - oy)
+
+    @staticmethod
+    def load_from_tiled_object(
+        obj, px: float, py: float, width: float, height: float
+    ) -> Gate:
+        gate = [
+            Gate(
+                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()
+                ],
+                bombable=obj.get_bool("bombable"),
+                dyn_id=obj.object_id,
+                name=obj.name,
+            )
+        ]
+
+        if obj.get_bool("has_teleport"):
+            if gate[0].facing_direction == Direction.NORTH:
+                py += 0.4
+            elif gate[0].facing_direction == Direction.SOUTH:
+                py -= 0.1
+
+            teleport = Teleport(
+                px=px,
+                py=py,
+                tileset_name="",
+                image_name="",
+                sprite_name="",
+                dst_map_name=obj.get_string("target_map"),
+                dst_px=obj.get_float("target_px"),
+                dst_py=obj.get_float("target_py"),
+                facing_direction=gate[0].facing_direction,
+                graphic_state=GraphicState.STANDING,
+                direction=gate[0].facing_direction,
+                invert_exit_direction=False,
+                relative=False,
+                sliding=False,
+                vertical=False,
+                dyn_id=gate[0].dyn_id + 2000,
+                name=f"Teleport of {gate[0].name}",
+            )
+
+            teleport.visible = False
+            teleport.sfx_on_trigger = "pass_door"
+
+            gate.append(teleport)
+
+        return gate

mima/objects/world/light_source.py

@@ -0,0 +1,124 @@
+from typing import Optional
+
+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
+from ..effects.light import Light
+from ..projectile import Projectile
+
+
+class LightSource(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        graphic_state: GraphicState,
+        facing_direction: Direction,
+        max_size: int,
+        dyn_id: int = -1,
+        name: str = "LightSource",
+    ):
+        assert graphic_state in [GraphicState.OFF, GraphicState.ON], (
+            f"graphic_state of LightSource {name}{dyn_id} must be either "
+            f"'off' or 'on', 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.LIGHT_SOURCE
+        self.graphic_state = graphic_state
+        self.facing_direction = facing_direction
+        self._max_size = max_size
+        self.active = self.graphic_state == GraphicState.ON
+        self._light: Optional[Projectile] = None
+
+        self.hitbox_px = 0.0
+        self.hitbox_py = 0.0
+        self.hitbox_width = 1.0
+        self.hitbox_height = 1.0
+        self.solid_vs_dyn = True
+        self.solid_vs_map = False
+        self.onscreen_collision_skippable = True
+        self._state_changed = True
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        if self._state_changed:
+            # self._set_sprite_state()
+            self._state_changed = False
+
+        if self.active:
+            if self._light is None:
+                self._light = Light(self, self._max_size)
+                self.engine.scene.add_effect(self._light)
+        else:
+            if self._light is not None:
+                self._light.kill()
+                self._light = None
+
+        self.graphic_state = (
+            GraphicState.ON if self.active else GraphicState.OFF
+        )
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if nature == Nature.SIGNAL:
+            self.active = True
+            self._state_changed = True
+            return True
+
+        if nature == Nature.NO_SIGNAL:
+            self.active = False
+            self._state_changed = True
+            return True
+
+        if nature == Nature.TALK:
+            self.active = not self.active
+            self._state_changed = True
+            return True
+
+    def draw_self(self, ox: float, oy: float):
+        self.sprite.draw_self(self.px - ox, self.py - oy)
+
+    def on_death(self) -> bool:
+        self._light.kill()
+        return True
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height):
+        light = LightSource(
+            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()
+            ],
+            max_size=obj.get_int("max_size", 32),
+            dyn_id=obj.object_id,
+            name=obj.name,
+        )
+
+        light.sprite.width = int(width * TILE_WIDTH)
+        light.sprite.height = int(height * TILE_HEIGHT)
+
+        return [light]