mima-engine 0.1.5__py3-none-any.whl → 0.2.1__py3-none-any.whl

mima/objects/world/oneway.py

@@ -3,7 +3,7 @@ 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 ...util.constants import ONEWAY_ACTIVATION_DELAY
 from ..animated_sprite import AnimatedSprite
 from ..dynamic import Dynamic
 
@@ -22,10 +22,11 @@ class Oneway(Dynamic):
         jump_vy: float,
         width: float,
         height: float,
+        tilemap,
         dyn_id=-1,
         name="Oneway",
     ):
-        super().__init__(name, px, py, dyn_id)
+        super().__init__(px, py, name, tilemap, dyn_id)
         self.sprite = AnimatedSprite(
             tileset_name,
             image_name,
@@ -36,8 +37,8 @@ class Oneway(Dynamic):
         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.sprite.width = int(width * self.engine.rtc.tile_width)
+        self.sprite.height = int(height * self.engine.rtc.tile_height)
 
         self.hitbox_px, self.hitbox_py = 0.0, 0.0
         self.hitbox_width, self.hitbox_height = 1.0, 1.0
@@ -50,6 +51,7 @@ class Oneway(Dynamic):
         self.activation_delay: float = ONEWAY_ACTIVATION_DELAY
         self.triggered: bool = False
         self.cooldown: float = 0.0
+        self.target = None
 
         if jump_vx < 0:
             self.jump_vx = jump_vx - 1
@@ -88,15 +90,16 @@ class Oneway(Dynamic):
             self.timer -= elapsed_time
 
         # Activation countdown reached 0 and the jump is initiated.
-        if self.timer <= 0.0:
+        if self.timer <= 0.0 and self.target is not None:
             self.engine.script.add_command(
-                CommandOnewayMove(target, self.jump_vx, self.jump_vy)
+                CommandOnewayMove(self.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
+        self.target = None
 
     def on_interaction(self, target, nature=Nature.WALK):
         if target.type == ObjectType.PLAYER and nature == Nature.WALK:
@@ -134,6 +137,7 @@ class Oneway(Dynamic):
                     return False
 
             self.triggered = True
+            self.target = target
             if self.timer <= 0.0:
                 self.timer = self.activation_delay
 
@@ -141,11 +145,11 @@ class Oneway(Dynamic):
 
         return False
 
-    def draw_self(self, ox: float, oy: float):
-        self.sprite.draw_self(self.px - ox, self.py - oy)
+    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, py, width, height):
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
         oneway = Oneway(
             px=px,
             py=py,
@@ -162,6 +166,7 @@ class Oneway(Dynamic):
             jump_vy=obj.get_float("jump_vy"),
             width=width,
             height=height,
+            tilemap=tilemap,
             dyn_id=obj.object_id,
             name=obj.name,
         )

mima/objects/world/pickup.py

@@ -8,8 +8,10 @@ from ..effects.walking_on_water import WalkingOnWater
 
 
 class Pickup(Dynamic):
-    def __init__(self, px: float, py: float, item_name: str, dyn_id=-1):
-        super().__init__("Pickup", px, py, dyn_id)
+    def __init__(
+        self, px: float, py: float, item_name: str, tilemap, dyn_id=0
+    ):
+        super().__init__(px, py, "Pickup", tilemap, dyn_id)
         self.type: ObjectType = ObjectType.PICKUP
         self.item = self.engine.get_item(item_name)
         self.collected = False
@@ -25,9 +27,10 @@ class Pickup(Dynamic):
         if self.collected:
             return False
 
-        if target.type == ObjectType.PLAYER:
+        pl = target.get_player()
+        if pl.value > 0:
             if self.item.on_interaction(target):
-                if self.engine.give_item(self.item):
+                if self.engine.give_item(self.item, pl):
                     self.collected = True
                     return True
             else:
@@ -35,7 +38,7 @@ class Pickup(Dynamic):
 
         return False
 
-    def draw_self(self, ox: float, oy: float):
+    def draw_self(self, ox: float, oy: float, camera_name: str = "display"):
         if self.collected:
             return
 
@@ -45,6 +48,7 @@ class Pickup(Dynamic):
                 (self.py - oy + 0.7) * self.item.sprite_height,
                 0.2875 * self.item.sprite_width,
                 BLACK,
+                camera_name,
             )
 
         self.engine.backend.draw_partial_sprite(
@@ -55,6 +59,7 @@ class Pickup(Dynamic):
             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):

mima/objects/world/switch.py

@@ -5,7 +5,6 @@ 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
 
@@ -21,14 +20,15 @@ class Switch(Dynamic):
         facing_direction: Direction,
         graphic_state: GraphicState,
         initial_signal=True,
-        dyn_id=-1,
+        tilemap=None,
+        dyn_id=0,
         name="Switch",
     ):
         assert graphic_state in [GraphicState.OPEN, GraphicState.CLOSED], (
             f"graphic_state of Switch {name}{dyn_id} must be either 'open'"
             f" or 'closed', but it {graphic_state}"
         )
-        super().__init__(name, px, py, dyn_id)
+        super().__init__(px, py, name, tilemap, dyn_id)
 
         self.sprite = AnimatedSprite(
             tileset_name,
@@ -62,13 +62,15 @@ class Switch(Dynamic):
             elapsed_time, self.facing_direction, self.graphic_state
         )
 
-    def draw_self(self, ox: float, oy: float):
+    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)
+        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 (
             nature == Nature.TALK
             and target.type == ObjectType.PLAYER
@@ -113,26 +115,26 @@ class Switch(Dynamic):
         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),
-                ),
-            )
+        # 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):
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
         switch = Switch(
             px=px,
             py=py,
@@ -146,12 +148,13 @@ class Switch(Dynamic):
                 obj.get_string("facing_direction", "south").upper()
             ],
             initial_signal=obj.get_bool("initial_signal", True),
+            tilemap=tilemap,
             dyn_id=obj.object_id,
             name=obj.name,
         )
 
-        switch.sprite.width = int(width * TILE_WIDTH)
-        switch.sprite.height = int(height * TILE_HEIGHT)
+        switch.sprite.width = int(width * Switch.engine.rtc.tile_width)
+        switch.sprite.height = int(height * Switch.engine.rtc.tile_height)
 
         ctr = 1
         while True:

mima/objects/world/teleport.py

@@ -1,4 +1,5 @@
 from __future__ import annotations
+
 import logging
 from typing import List, Optional
 
@@ -12,8 +13,7 @@ from ...types.direction import Direction
 from ...types.graphic_state import GraphicState
 from ...types.nature import Nature
 from ...types.object import ObjectType
-from ...util.colors import RED
-from ...util.constants import TILE_HEIGHT, TILE_WIDTH
+from ...types.player import Player
 from ..animated_sprite import AnimatedSprite
 from ..dynamic import Dynamic
 
@@ -38,13 +38,18 @@ class Teleport(Dynamic):
         relative: bool = False,
         sliding: bool = False,
         vertical: bool = False,
+        tilemap=None,
         dyn_id: int = -1,
         name="Teleport",
     ):
-        super().__init__(name, px, py, dyn_id)
+        super().__init__(px, py, name, tilemap, dyn_id)
 
         self.sprite = AnimatedSprite(
-            tileset_name, image_name, sprite_name, graphic_state, facing_direction
+            tileset_name,
+            image_name,
+            sprite_name,
+            graphic_state,
+            facing_direction,
         )
 
         self.type = ObjectType.TELEPORT
@@ -68,7 +73,10 @@ class Teleport(Dynamic):
         self.sfx_on_trigger: str = ""
 
     def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
-        self.sprite.update(elapsed_time, self.facing_direction, self.graphic_state)
+        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:
@@ -81,91 +89,101 @@ class Teleport(Dynamic):
         if self.has_sprite and not self.visible:
             return False
 
+        pt = target.get_player()
         if (
             nature == Nature.WALK
-            and target.type == ObjectType.PLAYER
-            and not self.engine.teleport_triggered
+            and pt != Player.P0
+            and not self.engine.is_teleport_active(pt)
         ):
-            self.engine.teleport_triggered = True
+            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)
-
-            # if self.relative:
-            #     if self.vertical:
-            #         dst_py += target.py
-            #     else:
-            #         dst_px += target.px
-
+            # 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(
-                        self.dst_map_name,
-                        target,
-                        dst_px,
-                        dst_py,
-                        dst_vx,
-                        dst_vy,
-                    )
-                )
-            else:
-                if self.triggered:
-                    return False
+            #     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)
+            new_direction = target.facing_direction
+            if self.invert_exit_direction:
+                new_direction = Direction(
+                    (target.facing_direction.value + 2) % 4
+                )
 
-                self.engine.script.add_command(
-                    CommandSerial(
+            cmd = CommandSerial(
+                [
+                    CommandScreenFade(),
+                    CommandParallel(
                         [
-                            CommandScreenFade(),
-                            CommandParallel(
-                                [
-                                    CommandChangeMap(self.dst_map_name, dst_px, dst_py),
-                                    CommandSetFacingDirection(target, new_direction),
-                                    CommandScreenFade(fadein=True),
-                                ]
+                            CommandChangeMap(
+                                self.dst_map_name, dst_px, dst_py
                             ),
-                        ],
-                    )
-                )
-                if self.sfx_on_trigger:
-                    self.engine.audio.play_sound(self.sfx_on_trigger)
+                            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
+            self.triggered = True
             return True
 
         return False
 
-    def draw_self(self, ox: float, oy: float):
+    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) * TILE_WIDTH,
-                (self.py + 0.5 - oy) * TILE_HEIGHT,
-                0.5 * TILE_WIDTH,
-                RED,
+                (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)
+            self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
 
     @staticmethod
-    def load_from_tiled_object(obj, px, py, width, height) -> List[Teleport]:
+    def load_from_tiled_object(
+        obj, px, py, width, height, tilemap
+    ) -> List[Teleport]:
         sprite_name = obj.get_string("sprite_name")
         tileset_name = obj.get_string("tileset_name")
         image_name = obj.get_string("tileset_name")
-        graphic_state = GraphicState[obj.get_string("graphic_state", "closed").upper()]
-        facing_direction = Direction[obj.get_string("facing_direction", "south").upper()]
+        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)
@@ -209,6 +227,7 @@ class Teleport(Dynamic):
                         relative=relative,
                         sliding=sliding,
                         vertical=False,
+                        tilemap=tilemap,
                         dyn_id=obj.object_id,
                         name=obj.name,
                     )
@@ -247,6 +266,7 @@ class Teleport(Dynamic):
                         relative=relative,
                         sliding=sliding,
                         vertical=True,
+                        tilemap=tilemap,
                         dyn_id=obj.object_id,
                         name=obj.name,
                     )
@@ -278,6 +298,7 @@ class Teleport(Dynamic):
                     relative=relative,
                     sliding=sliding,
                     vertical=vertical,
+                    tilemap=tilemap,
                     dyn_id=obj.object_id,
                     name=obj.name,
                 )

mima/scene_engine.py

@@ -5,6 +5,7 @@ from .states.game_state import GameState
 from .types.keys import Key as K
 from .types.mode import Mode
 from .types.nature import Nature
+from .types.player import Player
 from .view.scene import Scene
 
 
@@ -25,12 +26,10 @@ class MimaSceneEngine(MimaEngine):
         self._scenes: Dict[str, Scene] = {}
         self._current_scene: Scene
 
-        self.all_games: Dict[str, GameState] = {}
-        self.current_game: str = ""
         self.save_timer_reset = 1.0
         self._save_timer = self.save_timer_reset
-        self.teleport_triggered: bool = False
-        self.dialog_active: bool = False
+        # self.teleport_triggered: bool = False
+        # self.dialog_active: bool = False
 
     def on_user_create(self):
         return True
@@ -58,19 +57,23 @@ class MimaSceneEngine(MimaEngine):
 
         return True
 
-    def change_map(self, map_name: str, px: float, py: float):
-        type_string = (
-            self.get_map(map_name).get_string("type", "local").upper()
-        )
-        if type_string == "WORLD":
-            type_string = "WORLD_MAP"
-        if type_string == "LOCAL":
-            type_string = "LOCAL_MAP"
-        mode = Mode[type_string]
+    def load_scene(self):
+        self.scene_stack
+
+    # def load_scene(self, map_name: str, px: float, py: float):
+    #     type_string = (
+    #         self.get_map(map_name).get_string("type", "local").upper()
+    #     )
+    #     if type_string == "WORLD":
+    #         type_string = "WORLD_MAP"
+    #     if type_string == "LOCAL":
+    #         type_string = "LOCAL_MAP"
+    #     mode = Mode[type_string]
 
-        self.scene_stack.append(mode)
-        self._scenes[self.scene_stack[-1]].change_map(map_name, px, py)
-        # print(self.scene_stack)
+    #     self.scene_stack.append(mode)
+    #     self._scenes[self.scene_stack[-1]].load_scene()
+    #     # self._scenes[self.scene_stack[-1]].change_map(map_name, px, py)
+    #     # print(self.scene_stack)
 
     @property
     def scene(self) -> Scene:
@@ -80,7 +83,3 @@ class MimaSceneEngine(MimaEngine):
     @property
     def previous_scene(self) -> Scene:
         return self._scenes[self.scene_stack[-2]]
-
-    @property
-    def game_state(self) -> GameState:
-        return self.all_games[self.current_game]

mima/scripts/command.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, List, Optional
+
+from ..types.player import Player
 
 if TYPE_CHECKING:
     from ..engine import MimaEngine
@@ -9,10 +11,13 @@ if TYPE_CHECKING:
 class Command:
     engine: MimaEngine
 
-    def __init__(self):
+    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
@@ -20,5 +25,14 @@ class Command:
     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

mima/scripts/commands/change_map.py

@@ -1,15 +1,34 @@
+from typing import List, Optional
+
+from ...types.player import Player
 from ..command import Command
 
 
 class CommandChangeMap(Command):
-    def __init__(self, map_name: str, spawn_px: float, spawn_py):
-        super().__init__()
+    def __init__(
+        self,
+        map_name: str,
+        spawn_px: float,
+        spawn_py,
+        players: Optional[List[Player]] = None,
+    ):
+        if players is None:
+            players = [Player.P1]
+
+        super().__init__(players)
 
         self._map_name: str = map_name
         self._spawn_px: float = spawn_px
         self._spawn_py: float = spawn_py
 
     def start(self):
-        self.engine.scene_stack.pop()
-        self.engine.change_map(self._map_name, self._spawn_px, self._spawn_py)
+        self.engine.get_view().unload_map(self.players[0])
+        self.engine.get_view().load_map(
+            self._map_name, self._spawn_px, self._spawn_py, self.players[0]
+        )
+        # self.engine.change_map(self._map_name, self._spawn_px, self._spawn_py)
         self.completed = True
+
+    def finalize(self):
+        self.engine.trigger_teleport(False, self.players[0])
+        self.engine.trigger_player_collision(False, self.players[0])

mima/scripts/commands/equip_weapon.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ..command import Command
+
+if TYPE_CHECKING:
+    from ...objects.creature import Creature
+    from ...types.weapon_slot import WeaponSlot
+    from ...usables.weapon import Weapon
+
+
+class CommandEquipWeapon(Command):
+    def __init__(self, weapon: Weapon, creature: Creature, slot: WeaponSlot):
+        super().__init__()
+
+        self._weapon: Weapon = weapon
+        self._target: Creature = creature
+        self._slot: WeaponSlot = slot
+
+    def start(self):
+        self._target.equip_weapon(self._slot, self._weapon)
+        self.completed = True

mima/scripts/commands/give_item.py

@@ -14,11 +14,13 @@ class CommandGiveItem(Command):
 
         self._item_name: str = item_name
 
-        if dynamic is None:
-            dynamic = self.engine.player
+        # if dynamic is None:
+        #     dynamic = self.engine.player
 
         self._dynamic: Dynamic = dynamic
 
     def start(self):
-        self.engine.give_item(self._item_name)
+        # if self._dynamic is None:
+        #     self._dynamic = self.engine.get_player(self.players[0])
+        self.engine.give_item(self._item_name, self.players[0])
         self.completed = True