mima-engine 0.4.0__py3-none-any.whl

mima/objects/world/gate.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+
+from typing import Optional
+
+from ...maps.tilemap import Tilemap
+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,
+        name: str = "Gate",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = 0,
+        graphic_state: GraphicState = GraphicState.STANDING,
+        facing_direction: Direction = Direction.SOUTH,
+        bombable: bool = False,
+    ):
+        if graphic_state not in (
+            GraphicState.OPEN,
+            GraphicState.CLOSED,
+            GraphicState.LOCKED,
+        ):
+            msg = (
+                f"graphic_state of Gate {name}{dyn_id} must be either 'open'"
+                f", 'closed', or 'locked', but it {graphic_state}"
+            )
+
+            raise ValueError(msg)
+
+        super().__init__(
+            px,
+            py,
+            name,
+            tilemap=tilemap,
+            sprite_name=sprite_name,
+            dyn_id=dyn_id,
+        )
+
+        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, camera_name: str = "display"):
+        self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
+
+    @staticmethod
+    def load_from_tiled_object(
+        obj, px: float, py: float, width: float, height: float, tilemap
+    ) -> Gate:
+        gate = [
+            Gate(
+                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()
+                ],
+                bombable=obj.get_bool("bombable"),
+            )
+        ]
+
+        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,
+                py,
+                f"Teleport of {gate[0].name}",
+                sprite_name="",
+                tilemap=tilemap,
+                dyn_id=gate[0].dyn_id + 2000,
+                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,
+            )
+
+            teleport.visible = False
+            teleport.sfx_on_trigger = "pass_door"
+
+            gate.append(teleport)
+
+        return gate

mima/objects/world/light_source.py

@@ -0,0 +1,121 @@
+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 ..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,
+        name: str = "LightSource",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        graphic_state: GraphicState = GraphicState.ON,
+        max_size: int = 32,
+    ):
+        if graphic_state not in [GraphicState.OFF, GraphicState.ON]:
+            msg = (
+                f"graphic_state of LightSource {name}{dyn_id} must be either "
+                f"'off' or 'on', but it is {graphic_state}"
+            )
+            raise ValueError(msg)
+
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+        )
+
+        self.type = ObjectType.LIGHT_SOURCE
+        self.graphic_state = graphic_state
+        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._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.get_view().add_effect(
+                    self._light, self.tilemap.name
+                )
+        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, camera_name: str = "display"):
+        self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
+
+    def on_death(self) -> bool:
+        self._light.kill()
+        return True
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
+        light = LightSource(
+            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", "on").upper()
+            ],
+            max_size=obj.get_int("max_size", 32),
+        )
+
+        # light.sprite.width = int(width * LightSource.engine.rtc.tile_width)
+        # light.sprite.height = int(height * LightSource.engine.rtc.tile_height)
+
+        return [light]

mima/objects/world/logic_gate.py

@@ -0,0 +1,157 @@
+from enum import Enum
+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 LogicFunction(Enum):
+    LOGIC_PASS = 0
+    LOGIC_NOT = 1
+    LOGIC_AND = 2
+    LOGIC_OR = 3
+    LOGIC_NAND = 4
+    LOGIC_NOR = 5
+    LOGIC_XOR = 6
+    LOGIC_IMPL = 7
+    LOGIC_EQUI = 8
+
+
+class LogicGate(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        name: str = "Logic Gate",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        mode: LogicFunction = LogicFunction.LOGIC_PASS,
+        initial_signal: bool = False,
+        visible: bool = False,
+    ):
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+        )
+
+        self.type = ObjectType.LOGIC_GATE
+        self.alignment = Alignment.NEUTRAL
+        self.visible = visible
+
+        self.input_id1: int = -1
+        self.input_id2: int = -1
+
+        self.mode = mode
+        self.signal: bool = False
+        self.last_signal: bool = False
+        self.input1: bool = False
+        self.input2: bool = False
+
+        self.listener_ids: List[int] = []
+        self.listeners: List[Dynamic] = []
+        self.send_initial_signal: bool = initial_signal
+        self.state_changed: bool = False
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        if self.mode == LogicFunction.LOGIC_NOT:
+            self.signal = not self.input1
+        elif self.mode == LogicFunction.LOGIC_AND:
+            self.signal = self.input1 and self.input2
+        elif self.mode == LogicFunction.LOGIC_OR:
+            self.signal = self.input1 or self.input2
+        else:
+            self.signal = self.input1
+
+        if self.last_signal != self.signal:
+            self.state_changed = True
+        else:
+            self.state_changed = False
+
+        if self.send_initial_signal or self.state_changed:
+            self.send_signal(self.signal)
+            self.send_initial_signal = False
+
+        self.last_signal = self.signal
+
+        self.graphic_state = (
+            GraphicState.ON if self.signal 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:
+            if target.dyn_id == self.input_id1:
+                self.input1 = True
+            elif target.dyn_id == self.input_id2:
+                self.input2 = True
+            else:
+                return False
+            return True
+        elif nature == Nature.NO_SIGNAL:
+            if target.dyn_id == self.input_id1:
+                self.input1 = False
+            elif target.dyn_id == self.input_id2:
+                self.input2 = False
+            else:
+                return False
+            return True
+
+        return False
+
+    def draw_self(self, ox: float, oy: float, camera_name: str = "display"):
+        if self.visible:
+            self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
+
+    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)
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
+        logic = LogicGate(
+            px,
+            py,
+            obj.name,
+            sprite_name=obj.get_string("sprite_name"),
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
+            mode=LogicFunction[obj.get_string("mode", "logic_pass").upper()],
+            initial_signal=obj.get_bool("initial_signal", False),
+            visible=obj.get_bool("visible", True),
+        )
+        logic.facing_direction = Direction[
+            obj.get_string("facing_direction", "south").upper()
+        ]
+        logic.graphic_state = GraphicState[
+            obj.get_string("graphic_state", "closed").upper()
+        ]
+        # logic.send_initial_signal =
+        # logic.sprite.width = int(width * LogicGate.engine.rtc.tile_width)
+        # logic.sprite.height = int(height * LogicGate.engine.rtc.tile_height)
+
+        ctr = 1
+        while True:
+            listener_id = obj.get_int(f"output{ctr}", -1)
+            if listener_id < 0:
+                break
+            logic.listener_ids.append(listener_id)
+            ctr += 1
+
+        return [logic]