mima-engine 0.1.0__py3-none-any.whl

mima/objects/world/logic_gate.py

@@ -0,0 +1,163 @@
+from enum import Enum
+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 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,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        graphic_state: GraphicState,
+        facing_direction: Direction,
+        mode=LogicFunction.LOGIC_PASS,
+        initial_signal=False,
+        visible=False,
+        dyn_id=-1,
+        name="Logic Gate",
+    ):
+        super().__init__(name, px, py, dyn_id)
+
+        self.sprite = AnimatedSprite(
+            tileset_name,
+            image_name,
+            sprite_name,
+            graphic_state,
+            facing_direction,
+        )
+        self.type = ObjectType.LOGIC_GATE
+        self.alignment = Alignment.NEUTRAL
+        self.graphic_state = graphic_state
+        self.facing_direction = facing_direction
+        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):
+        if self.visible:
+            self.sprite.draw_self(self.px - ox, self.py - oy)
+
+    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):
+        logic = LogicGate(
+            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()
+            ],
+            mode=LogicFunction[obj.get_string("mode", "logic_pass").upper()],
+            initial_signal=obj.get_bool("initial_signal", False),
+            visible=obj.get_bool("visible", True),
+            dyn_id=obj.object_id,
+            name=obj.name,
+        )
+
+        # logic.send_initial_signal =
+        logic.sprite.width = int(width * TILE_WIDTH)
+        logic.sprite.height = int(height * 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]

mima/objects/world/movable.py

@@ -0,0 +1,338 @@
+import math
+from typing import List, Optional
+
+from ...types.alignment import Alignment
+from ...types.damage import Damage
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
+from ...types.keys import Key as K
+from ...types.nature import Nature
+from ...types.object import ObjectType
+from ...util.colors import BLACK
+from ...util.constants import TILE_HEIGHT, TILE_WIDTH
+from ..animated_sprite import AnimatedSprite
+from ..dynamic import Dynamic
+from ..projectile import Projectile
+
+
+class Movable(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        facing_direction: Direction,
+        graphic_state: GraphicState,
+        mrange: float,
+        liftable: bool,
+        destroyable: bool,
+        movable: bool,
+        intangible: bool,
+        force_collision_check: bool,
+        dyn_id=-1,
+        name="Movable",
+    ):
+        super().__init__(name, px, py, dyn_id)
+
+        self.sprite = AnimatedSprite(
+            tileset_name,
+            image_name,
+            sprite_name,
+            graphic_state,
+            facing_direction,
+        )
+        self.type = ObjectType.MOVABLE
+        self.alignment = Alignment.NEUTRAL
+        self.facing_direction = facing_direction
+        self.graphic_state = graphic_state
+        self.solid_vs_map = True
+
+        self.range = mrange
+        self.total_range = 0
+        self.spawn_px = px
+        self.spawn_py = py
+
+        self.liftable = liftable
+        self.destroyable = destroyable
+        self.movable = movable
+        self.intangible = intangible
+        self.moving = False
+        self.lift_started = False
+        self.lifted = False
+        self.thrown = False
+        self.visible = True
+        self.visible_pz = 0.0
+        self.actor: Optional[Dynamic] = None
+        self.vx_mask = 0
+        self.vy_mask = 0
+        self.move_direction: str = ""
+        self.onscreen_collision_skippable = (
+            not self.movable and not force_collision_check
+        )
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        if self.intangible:
+            self.solid_vs_dyn = False
+        else:
+            self.solid_vs_dyn = (
+                self.visible and not self.lifted and not self.thrown
+            )
+        if self.pz > 1.0:
+            self.solid_vs_map = False
+        else:
+            self.solid_vs_map = True
+
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+        if self.thrown:
+            return self._throw()
+
+        self.vx = self.vy = 0.0
+
+        if self.moving:
+            return self._move()
+
+        if self.lift_started or self.lifted:
+            return self._lift()
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if self.moving:
+            return False
+        if self.lifted:
+            return False
+
+        if target.type == ObjectType.PLAYER:
+            if nature == Nature.TALK and self.liftable and target.can_lift:
+                self.lift_started = True
+                self.actor = target
+                self.solid_vs_dyn = False
+                target.can_attack = False
+                return True
+
+            if (
+                self.movable
+                and self.visible
+                and self.total_range < self.range
+                and target.graphic_state
+                in [
+                    GraphicState.WALKING,
+                    GraphicState.PUSHING,
+                ]
+            ):
+                if (
+                    target.facing_direction == Direction.WEST
+                    and self.engine.keys.key_held(K.LEFT)
+                    and target.vy == 0
+                ):
+                    self.move_direction = K.LEFT
+                    self.vx_mask = -1
+                elif (
+                    target.facing_direction == Direction.EAST
+                    and self.engine.keys.key_held(K.RIGHT)
+                    and target.vy == 0
+                ):
+                    self.move_direction = K.RIGHT
+                    self.vx_mask = 1
+                elif (
+                    target.facing_direction == Direction.SOUTH
+                    and self.engine.keys.key_held(K.DOWN)
+                    and target.vx == 0
+                ):
+                    self.move_direction = K.DOWN
+                    self.vy_mask = 1
+                elif (
+                    target.facing_direction == Direction.NORTH
+                    and self.engine.keys.key_held(K.UP)
+                    and target.vx == 0
+                ):
+                    self.move_direction = K.UP
+                    self.vy_mask = -1
+                else:
+                    return False
+
+                self.actor = target
+                self.moving = True
+                self.actor.lock_graphic_state(GraphicState.PUSHING)
+                return True
+
+        elif target.type == ObjectType.PROJECTILE:
+            if self.destroyable:
+                damage = target.damage - self.attributes.defense[target.dtype]
+                if damage > 0:
+                    self.kill()
+                    if target.one_hit:
+                        target.kill()
+                return True
+
+        elif nature == Nature.SIGNAL:
+            self.visible = False
+            return True
+
+        elif nature == Nature.NO_SIGNAL:
+            self.visible = True
+            return True
+
+        return False
+
+    def draw_self(self, ox: float, oy: float):
+        if not self.visible:
+            return
+
+        py = self.py - oy - (self.pz + self.visible_pz)
+
+        if self.pz != 0:
+            self.engine.backend.fill_circle(
+                (self.px - ox + 0.5) * self.sprite.width,
+                (self.py - oy + 0.7) * self.sprite.height,
+                0.3125 * self.sprite.width,
+                BLACK,
+            )
+        self.sprite.draw_self(self.px - ox, py)
+
+    def _throw(self):
+        if self.pz < 0.5:
+            self.solid_vs_dyn = True
+        if self.pz > 0:
+            return
+
+        self._create_impact()
+
+        # self.solid_vs_dyn = True
+        self.thrown = False
+        self.vx = self.vy = 0.0
+        if self.destroyable:
+            self.kill()
+        return
+
+    def _move(self):
+        if self.actor.graphic_state == GraphicState.PUSHING:
+            stop_moving = False
+            for button in [K.DOWN, K.LEFT, K.UP, K.RIGHT]:
+                if button == self.move_direction:
+                    if self.engine.keys.key_held(button):
+                        self.vx = self.vx_mask
+                        self.vy = self.vy_mask
+                else:
+                    if self.engine.keys.key_held(button):
+                        stop_moving = True
+                        self.vx = 0
+                        self.vy = 0
+                        break
+            if (
+                abs(self.actor.px - self.px) > 1.1
+                or abs(self.actor.py - self.py) > 1.1
+            ):
+                stop_moving = True
+
+            if not stop_moving and abs(self.vx) > abs(self.vy):
+                self.vy = 0
+            elif not stop_moving and abs(self.vy) > abs(self.vx):
+                self.vx = 0
+            else:
+                self.vx = self.vy = 0.0
+
+        dx = self.px - self.spawn_px
+        dy = self.py - self.spawn_py
+        self.total_range = math.sqrt(dx * dx + dy * dy)
+
+        if self.total_range >= self.range:
+            self.vx = self.vy = 0.0
+
+        if self.vx == 0.0 and self.vy == 0.0:
+            self.moving = False
+            self.vx_mask = self.vy_mask = 0
+            self.actor.unlock_graphic_state()
+            self.engine.audio.stop_sound("move_block")
+        else:
+            self.engine.audio.play_sound("move_block")
+        return
+
+    def _lift(self):
+        if self.lifted and self.engine.keys.new_key_press(K.A):
+            # Throw away
+            self.vx = self.vy = 0
+            if self.actor.facing_direction == Direction.SOUTH:
+                self.vy = 4
+            if self.actor.facing_direction == Direction.WEST:
+                self.vx = -4
+            if self.actor.facing_direction == Direction.NORTH:
+                self.vy = -4
+            if self.actor.facing_direction == Direction.EAST:
+                self.vx = 4
+
+            self.vz = 6.0
+            self.pz = self.actor.pz + 0.9
+            self.visible_pz = 0
+            self.actor.can_attack = True
+            self.lifted = False
+            self.actor = None
+            self.thrown = True
+
+        elif self.lift_started and self.engine.keys.new_key_release(K.A):
+            self.lift_started = False
+            self.lifted = True
+            self.solid_vs_dyn = False
+        else:
+            self.solid_vs_dyn = False
+            self.px = self.actor.px
+            self.py = self.actor.py
+            self.visible_pz = self.actor.pz + 0.9
+            self.vx = self.vy = 0.0
+
+    def _create_impact(self):
+        impact: List[Projectile] = []
+        impact.append(
+            Projectile(self.px + 0.5, self.py + 0.5, 0, 0, 0.2, self.alignment)
+        )
+        impact.append(
+            Projectile(self.px - 0.5, self.py + 0.5, 0, 0, 0.2, self.alignment)
+        )
+        impact.append(
+            Projectile(self.px - 0.5, self.py - 0.5, 0, 0, 0.2, self.alignment)
+        )
+        impact.append(
+            Projectile(self.px + 0.5, self.py - 0.5, 0, 0, 0.2, self.alignment)
+        )
+
+        for pro in impact:
+            pro.sprite.name = "explosion"
+            pro.solid_vs_dyn = False
+            pro.solid_vs_map = False
+            pro.damage = 5
+            self.engine.scene.add_projectile(pro)
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height):
+        movable = Movable(
+            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", "standing").upper()
+            ],
+            facing_direction=Direction[
+                obj.get_string("facing_direction", "south").upper()
+            ],
+            mrange=obj.get_float("range"),
+            liftable=obj.get_bool("liftable"),
+            destroyable=obj.get_bool("destroyable"),
+            movable=obj.get_bool("movable"),
+            intangible=obj.get_bool("intangible"),
+            force_collision_check=obj.get_bool("force_collision_check"),
+            dyn_id=obj.object_id,
+            name=obj.name,
+        )
+        movable.sprite.width = int(width * TILE_WIDTH)
+        movable.sprite.height = int(height * TILE_HEIGHT)
+        for dt in Damage:
+            movable.attributes.defense[dt] = obj.get_int(
+                f"defense_{dt.name.lower()}"
+            )
+
+        return [movable]

mima/objects/world/oneway.py

@@ -0,0 +1,168 @@
+from ...scripts.commands.oneway_move import CommandOnewayMove
+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 ONEWAY_ACTIVATION_DELAY, TILE_HEIGHT, TILE_WIDTH
+from ..animated_sprite import AnimatedSprite
+from ..dynamic import Dynamic
+
+
+class Oneway(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        facing_direction: Direction,
+        graphic_state: GraphicState,
+        jump_vx: float,
+        jump_vy: float,
+        width: float,
+        height: float,
+        dyn_id=-1,
+        name="Oneway",
+    ):
+        super().__init__(name, px, py, dyn_id)
+        self.sprite = AnimatedSprite(
+            tileset_name,
+            image_name,
+            sprite_name,
+            graphic_state,
+            facing_direction,
+        )
+        self.type = ObjectType.ONEWAY
+        self.graphic_state = graphic_state
+        self.facing_direction = facing_direction
+        self.sprite.width = int(width * TILE_WIDTH)
+        self.sprite.height = int(height * TILE_HEIGHT)
+
+        self.hitbox_px, self.hitbox_py = 0.0, 0.0
+        self.hitbox_width, self.hitbox_height = 1.0, 1.0
+        self.solid_vs_map = False
+
+        self.width: float = width
+        self.height: float = height
+        self.jump_vx: float = 0.0
+        self.jump_vy: float = 0.0
+        self.activation_delay: float = ONEWAY_ACTIVATION_DELAY
+        self.triggered: bool = False
+        self.cooldown: float = 0.0
+
+        if jump_vx < 0:
+            self.jump_vx = jump_vx - 1
+            self.hitbox_px += 0.1
+        elif jump_vx > 0:
+            self.jump_vx = jump_vx + 1
+            self.hitbox_px -= 0.1
+
+        if jump_vy < 0:
+            self.jump_vy = jump_vy - 1
+            self.hitbox_py += 0.1
+        elif jump_vy > 0:
+            self.jump_vy = jump_vy + 1
+            self.hitbox_py -= 0.1
+
+    def update(self, elapsed_time, target=None):
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+        # Can only be triggered again after a certain time has passed.
+        if self.cooldown >= 0.0:
+            self.cooldown -= elapsed_time
+            return
+        else:
+            self.cooldown = 0.0
+
+        # If no interaction happened in a frame, the activation timer
+        # gets resetted.
+        if not self.triggered:
+            self.timer = 0.0
+            return
+
+        # Activation countdown
+        if self.timer > 0.0:
+            self.timer -= elapsed_time
+
+        # Activation countdown reached 0 and the jump is initiated.
+        if self.timer <= 0.0:
+            self.engine.script.add_command(
+                CommandOnewayMove(target, self.jump_vx, self.jump_vy)
+            )
+            self.cooldown = 2.0
+
+        # Reset the triggered flag so it has to be activated again
+        # by interaction
+        self.triggered = False
+
+    def on_interaction(self, target, nature=Nature.WALK):
+        if target.type == ObjectType.PLAYER and nature == Nature.WALK:
+            # No interaction when target is higher than the oneway
+            if target.pz > 0:
+                return False
+
+            # We have to check that target is not placed "more" in the
+            # target direction than the oneway
+            if (
+                self.jump_vx < 0
+                and target.px < self.px + self.width - target.hitbox_px
+            ):
+                return False
+            if self.jump_vx > 0 and target.px >= self.px:
+                return False
+            if (
+                self.jump_vy < 0
+                and target.py <= self.py + self.height - target.hitbox_py
+            ):
+                return False
+            if self.jump_vy > 0 and target.py >= self.py:
+                return False
+
+            if self.jump_vx == 0:
+                if target.px >= self.px + self.width:
+                    return False
+                if target.px + 1.0 <= self.px:
+                    return False
+
+            if self.jump_vy == 0:
+                if target.py >= self.py + self.height:
+                    return False
+                if target.py + 1.0 <= self.py:
+                    return False
+
+            self.triggered = True
+            if self.timer <= 0.0:
+                self.timer = self.activation_delay
+
+            return True
+
+        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, py, width, height):
+        oneway = Oneway(
+            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", "standing").upper()
+            ],
+            facing_direction=Direction[
+                obj.get_string("facing_direction", "south").upper()
+            ],
+            jump_vx=obj.get_float("jump_vx"),
+            jump_vy=obj.get_float("jump_vy"),
+            width=width,
+            height=height,
+            dyn_id=obj.object_id,
+            name=obj.name,
+        )
+        return [oneway]