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

mima/objects/world/color_switch.py

@@ -1,14 +1,18 @@
-from typing import List, Optional, Union
+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 ...util.constants import TILE_HEIGHT, TILE_WIDTH
 from ..dynamic import Dynamic
 from .switch import Switch
 
+if TYPE_CHECKING:
+    from ...maps.tilemap import Tilemap
+
 
 class ColorSwitch(Switch):
     def __init__(
@@ -22,10 +26,10 @@ class ColorSwitch(Switch):
         graphic_state: GraphicState,
         color: GateColor,
         initial_signal=True,
+        tilemap: Tilemap = None,
         dyn_id=-1,
         name="ColorSwitch",
     ):
-
         super().__init__(
             px,
             py,
@@ -35,6 +39,7 @@ class ColorSwitch(Switch):
             facing_direction,
             graphic_state,
             initial_signal,
+            tilemap,
             dyn_id,
             name,
         )
@@ -80,7 +85,7 @@ class ColorSwitch(Switch):
         return False
 
     @staticmethod
-    def load_from_tiled_object(obj, px, py, width, height):
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
         switch = ColorSwitch(
             px=px,
             py=py,
@@ -95,11 +100,12 @@ class ColorSwitch(Switch):
             ],
             color=GateColor[obj.get_string("color", "red").upper()],
             initial_signal=False,
+            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 * ColorSwitch.engine.rtc.tile_width)
+        switch.sprite.height = int(height * ColorSwitch.engine.rtc.tile_height)
 
         return [switch]

mima/objects/world/container.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from typing import List, Optional
 
 from ...scripts.commands.give_item import CommandGiveItem
@@ -14,6 +15,8 @@ from ...types.object import ObjectType
 from ..animated_sprite import AnimatedSprite
 from ..dynamic import Dynamic
 
+LOG = logging.getLogger(__name__)
+
 
 class Container(Dynamic):
     def __init__(
@@ -26,6 +29,7 @@ class Container(Dynamic):
         graphic_state: GraphicState,
         facing_direction: Direction,
         item_name: str,
+        tilemap=None,
         dyn_id: int = -1,
         name: str = "Container",
     ):
@@ -36,7 +40,7 @@ class Container(Dynamic):
             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)
+        super().__init__(px, py, name, tilemap, dyn_id)
 
         self.sprite = AnimatedSprite(
             tileset_name,
@@ -59,7 +63,6 @@ class Container(Dynamic):
         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):
@@ -76,11 +79,11 @@ class Container(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:
             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 nature == Nature.SIGNAL:
@@ -114,7 +117,7 @@ class Container(Dynamic):
                     elif self.item_name == "Key":
                         cgr = CommandGiveResource(target, keys=self.amount)
                     else:
-                        print(f"Invalid resource type: {self.item_name}")
+                        LOG.error(f"Invalid resource type: {self.item_name}")
                         return False
 
                     self.engine.script.add_command(
@@ -125,10 +128,12 @@ class Container(Dynamic):
                                 cgr,
                             ],
                             CommandParallel.FIRST_COMPLETED,
-                        )
+                        ),
+                        players=[target.get_player()],
                     )
 
                 else:
+
                     self.engine.script.add_command(
                         CommandParallel(
                             [
@@ -139,7 +144,8 @@ class Container(Dynamic):
                                 CommandGiveItem(self.item_name, target),
                             ],
                             CommandParallel.FIRST_COMPLETED,
-                        )
+                        ),
+                        players=[target.get_player()],
                     )
                 self.closed = False
                 self.state_changed = True
@@ -148,7 +154,9 @@ class Container(Dynamic):
         return False
 
     @staticmethod
-    def load_from_tiled_object(obj, px, py, width, height) -> List[Container]:
+    def load_from_tiled_object(
+        obj, px, py, width, height, tilemap
+    ) -> List[Container]:
         container = Container(
             px=px,
             py=py,
@@ -162,6 +170,7 @@ class Container(Dynamic):
                 obj.get_string("facing_direction", "south").upper()
             ],
             item_name=obj.get_string("item_name"),
+            tilemap=tilemap,
             dyn_id=obj.object_id,
             name=obj.name,
         )

mima/objects/world/floor_switch.py

@@ -2,7 +2,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 ..dynamic import Dynamic
 from .switch import Switch
 
@@ -18,6 +17,7 @@ class FloorSwitch(Switch):
         facing_direction: Direction,
         graphic_state: GraphicState,
         initial_signal=True,
+        tilemap=None,
         dyn_id=-1,
         name="Floor Switch",
     ):
@@ -30,6 +30,7 @@ class FloorSwitch(Switch):
             facing_direction,
             graphic_state,
             initial_signal,
+            tilemap,
             dyn_id,
             name,
         )
@@ -79,7 +80,7 @@ class FloorSwitch(Switch):
         return False
 
     @staticmethod
-    def load_from_tiled_object(obj, px, py, width, height):
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
         fswitch = FloorSwitch(
             px=px,
             py=py,
@@ -93,11 +94,14 @@ class FloorSwitch(Switch):
                 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,
         )
-        fswitch.sprite.width = int(width * TILE_WIDTH)
-        fswitch.sprite.height = int(height * TILE_HEIGHT)
+        fswitch.sprite.width = int(width * FloorSwitch.engine.rtc.tile_width)
+        fswitch.sprite.height = int(
+            height * FloorSwitch.engine.rtc.tile_height
+        )
 
         ctr = 1
         while True:

mima/objects/world/gate.py

@@ -21,7 +21,8 @@ class Gate(Dynamic):
         graphic_state: GraphicState,
         facing_direction: Direction,
         bombable: bool = False,
-        dyn_id: int = -1,
+        tilemap=None,
+        dyn_id: int = 0,
         name: str = "Gate",
     ):
         assert graphic_state in [
@@ -33,7 +34,7 @@ class Gate(Dynamic):
             f", 'closed', or 'locked', but it {graphic_state}"
         )
 
-        super().__init__(name, px, py, dyn_id)
+        super().__init__(px, py, name, tilemap, dyn_id)
 
         self.sprite = AnimatedSprite(
             tileset_name,
@@ -114,12 +115,12 @@ class Gate(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: float, py: float, width: float, height: float
+        obj, px: float, py: float, width: float, height: float, tilemap
     ) -> Gate:
         gate = [
             Gate(
@@ -135,6 +136,7 @@ class Gate(Dynamic):
                     obj.get_string("facing_direction", "south").upper()
                 ],
                 bombable=obj.get_bool("bombable"),
+                tilemap=tilemap,
                 dyn_id=obj.object_id,
                 name=obj.name,
             )
@@ -162,6 +164,7 @@ class Gate(Dynamic):
                 relative=False,
                 sliding=False,
                 vertical=False,
+                tilemap=tilemap,
                 dyn_id=gate[0].dyn_id + 2000,
                 name=f"Teleport of {gate[0].name}",
             )

mima/objects/world/light_source.py

@@ -4,7 +4,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
 from ..effects.light import Light
@@ -22,6 +21,7 @@ class LightSource(Dynamic):
         graphic_state: GraphicState,
         facing_direction: Direction,
         max_size: int,
+        tilemap=None,
         dyn_id: int = -1,
         name: str = "LightSource",
     ):
@@ -29,7 +29,7 @@ class LightSource(Dynamic):
             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)
+        super().__init__(px, py, name, tilemap, dyn_id)
 
         self.sprite = AnimatedSprite(
             tileset_name,
@@ -52,7 +52,6 @@ class LightSource(Dynamic):
         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):
@@ -63,7 +62,9 @@ class LightSource(Dynamic):
         if self.active:
             if self._light is None:
                 self._light = Light(self, self._max_size)
-                self.engine.scene.add_effect(self._light)
+                self.engine.get_view().add_effect(
+                    self._light, self.tilemap.name
+                )
         else:
             if self._light is not None:
                 self._light.kill()
@@ -92,15 +93,15 @@ class LightSource(Dynamic):
             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 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):
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
         light = LightSource(
             px=px,
             py=py,
@@ -114,11 +115,12 @@ class LightSource(Dynamic):
                 obj.get_string("facing_direction", "south").upper()
             ],
             max_size=obj.get_int("max_size", 32),
+            tilemap=tilemap,
             dyn_id=obj.object_id,
             name=obj.name,
         )
 
-        light.sprite.width = int(width * TILE_WIDTH)
-        light.sprite.height = int(height * TILE_HEIGHT)
+        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

@@ -6,7 +6,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
 
@@ -36,10 +35,11 @@ class LogicGate(Dynamic):
         mode=LogicFunction.LOGIC_PASS,
         initial_signal=False,
         visible=False,
+        tilemap=None,
         dyn_id=-1,
         name="Logic Gate",
     ):
-        super().__init__(name, px, py, dyn_id)
+        super().__init__(px, py, name, tilemap, dyn_id)
 
         self.sprite = AnimatedSprite(
             tileset_name,
@@ -116,9 +116,9 @@ class LogicGate(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.visible:
-            self.sprite.draw_self(self.px - ox, self.py - oy)
+            self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
 
     def send_signal(self, nature: Union[Nature, bool]):
         if isinstance(nature, bool):
@@ -128,7 +128,7 @@ class LogicGate(Dynamic):
             listener.on_interaction(self, nature)
 
     @staticmethod
-    def load_from_tiled_object(obj, px, py, width, height):
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
         logic = LogicGate(
             px=px,
             py=py,
@@ -144,13 +144,14 @@ class LogicGate(Dynamic):
             mode=LogicFunction[obj.get_string("mode", "logic_pass").upper()],
             initial_signal=obj.get_bool("initial_signal", False),
             visible=obj.get_bool("visible", True),
+            tilemap=tilemap,
             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)
+        logic.sprite.width = int(width * LogicGate.engine.rtc.tile_width)
+        logic.sprite.height = int(height * LogicGate.engine.rtc.tile_height)
 
         ctr = 1
         while True:

mima/objects/world/movable.py

@@ -9,7 +9,6 @@ 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
@@ -31,10 +30,11 @@ class Movable(Dynamic):
         movable: bool,
         intangible: bool,
         force_collision_check: bool,
+        tilemap=None,
         dyn_id=-1,
         name="Movable",
     ):
-        super().__init__(name, px, py, dyn_id)
+        super().__init__(px, py, name, tilemap, dyn_id)
 
         self.sprite = AnimatedSprite(
             tileset_name,
@@ -68,9 +68,10 @@ class Movable(Dynamic):
         self.vx_mask = 0
         self.vy_mask = 0
         self.move_direction: str = ""
-        self.onscreen_collision_skippable = (
-            not self.movable and not force_collision_check
-        )
+        self.moves_on_collision = self.movable or self.destroyable
+        # 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:
@@ -97,7 +98,9 @@ class Movable(Dynamic):
             return self._move()
 
         if self.lift_started or self.lifted:
+            self.moves_on_collision = True
             return self._lift()
+        self.moves_on_collision = self.movable or self.destroyable
 
     def on_interaction(self, target: Dynamic, nature: Nature):
         if self.moving:
@@ -105,7 +108,8 @@ class Movable(Dynamic):
         if self.lifted:
             return False
 
-        if target.type == ObjectType.PLAYER:
+        pt = target.get_player()
+        if pt.value > 0:
             if nature == Nature.TALK and self.liftable and target.can_lift:
                 self.lift_started = True
                 self.actor = target
@@ -118,35 +122,32 @@ class Movable(Dynamic):
                 and self.visible
                 and self.total_range < self.range
                 and target.graphic_state
-                in [
-                    GraphicState.WALKING,
-                    GraphicState.PUSHING,
-                ]
+                in [GraphicState.WALKING, GraphicState.PUSHING]
             ):
                 if (
                     target.facing_direction == Direction.WEST
-                    and self.engine.keys.key_held(K.LEFT)
+                    and self.engine.keys.key_held(K.LEFT, pt)
                     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 self.engine.keys.key_held(K.RIGHT, pt)
                     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 self.engine.keys.key_held(K.DOWN, pt)
                     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 self.engine.keys.key_held(K.UP, pt)
                     and target.vx == 0
                 ):
                     self.move_direction = K.UP
@@ -157,6 +158,7 @@ class Movable(Dynamic):
                 self.actor = target
                 self.moving = True
                 self.actor.lock_graphic_state(GraphicState.PUSHING)
+
                 return True
 
         elif target.type == ObjectType.PROJECTILE:
@@ -178,7 +180,7 @@ class Movable(Dynamic):
 
         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:
             return
 
@@ -190,8 +192,9 @@ class Movable(Dynamic):
                 (self.py - oy + 0.7) * self.sprite.height,
                 0.3125 * self.sprite.width,
                 BLACK,
+                camera_name,
             )
-        self.sprite.draw_self(self.px - ox, py)
+        self.sprite.draw_self(self.px - ox, py, camera_name)
 
     def _throw(self):
         if self.pz < 0.5:
@@ -213,11 +216,15 @@ class Movable(Dynamic):
             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):
+                    if self.engine.keys.key_held(
+                        button, self.actor.get_player()
+                    ):
                         self.vx = self.vx_mask
                         self.vy = self.vy_mask
                 else:
-                    if self.engine.keys.key_held(button):
+                    if self.engine.keys.key_held(
+                        button, self.actor.get_player()
+                    ):
                         stop_moving = True
                         self.vx = 0
                         self.vy = 0
@@ -252,7 +259,9 @@ class Movable(Dynamic):
         return
 
     def _lift(self):
-        if self.lifted and self.engine.keys.new_key_press(K.A):
+        if self.lifted and self.engine.keys.new_key_press(
+            K.A, self.actor.get_player()
+        ):
             # Throw away
             self.vx = self.vy = 0
             if self.actor.facing_direction == Direction.SOUTH:
@@ -272,7 +281,9 @@ class Movable(Dynamic):
             self.actor = None
             self.thrown = True
 
-        elif self.lift_started and self.engine.keys.new_key_release(K.A):
+        elif self.lift_started and self.engine.keys.new_key_release(
+            K.A, self.actor.get_player()
+        ):
             self.lift_started = False
             self.lifted = True
             self.solid_vs_dyn = False
@@ -286,16 +297,48 @@ class Movable(Dynamic):
     def _create_impact(self):
         impact: List[Projectile] = []
         impact.append(
-            Projectile(self.px + 0.5, self.py + 0.5, 0, 0, 0.2, self.alignment)
+            Projectile(
+                self.px + 0.5,
+                self.py + 0.5,
+                0,
+                0,
+                0.2,
+                self.alignment,
+                self.tilemap,
+            )
         )
         impact.append(
-            Projectile(self.px - 0.5, self.py + 0.5, 0, 0, 0.2, self.alignment)
+            Projectile(
+                self.px - 0.5,
+                self.py + 0.5,
+                0,
+                0,
+                0.2,
+                self.alignment,
+                self.tilemap,
+            )
         )
         impact.append(
-            Projectile(self.px - 0.5, self.py - 0.5, 0, 0, 0.2, self.alignment)
+            Projectile(
+                self.px - 0.5,
+                self.py - 0.5,
+                0,
+                0,
+                0.2,
+                self.alignment,
+                self.tilemap,
+            )
         )
         impact.append(
-            Projectile(self.px + 0.5, self.py - 0.5, 0, 0, 0.2, self.alignment)
+            Projectile(
+                self.px + 0.5,
+                self.py - 0.5,
+                0,
+                0,
+                0.2,
+                self.alignment,
+                self.tilemap,
+            )
         )
 
         for pro in impact:
@@ -303,10 +346,10 @@ class Movable(Dynamic):
             pro.solid_vs_dyn = False
             pro.solid_vs_map = False
             pro.damage = 5
-            self.engine.scene.add_projectile(pro)
+            self.engine.view.add_projectile(pro, self.tilemap.name)
 
     @staticmethod
-    def load_from_tiled_object(obj, px, py, width, height):
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
         movable = Movable(
             px=px,
             py=py,
@@ -325,11 +368,12 @@ class Movable(Dynamic):
             movable=obj.get_bool("movable"),
             intangible=obj.get_bool("intangible"),
             force_collision_check=obj.get_bool("force_collision_check"),
+            tilemap=tilemap,
             dyn_id=obj.object_id,
             name=obj.name,
         )
-        movable.sprite.width = int(width * TILE_WIDTH)
-        movable.sprite.height = int(height * TILE_HEIGHT)
+        movable.sprite.width = int(width * Movable.engine.rtc.tile_width)
+        movable.sprite.height = int(height * Movable.engine.rtc.tile_height)
         for dt in Damage:
             movable.attributes.defense[dt] = obj.get_int(
                 f"defense_{dt.name.lower()}"