mima-engine 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

mima/objects/effects/colorize_screen.py

@@ -1,5 +1,8 @@
+from typing import List, Optional
+
 from ...types.alignment import Alignment
-from ...util.colors import Color, BLACK
+from ...types.player import Player
+from ...util.colors import BLACK, Color
 from ...util.constants import HEIGHT, WIDTH
 from ..dynamic import Dynamic
 from ..projectile import Projectile
@@ -12,14 +15,18 @@ class ColorizeScreen(Projectile):
         alpha=BLACK.alpha,
         duration: float = -1.0,
         to_filter: bool = False,
+        cameras: Optional[List[str]] = None,
     ):
-        super().__init__(0, 0, 0, 0, duration, Alignment.GOOD)
+        super().__init__(0, 0, 0, 0, duration, Alignment.GOOD, None)
         self.layer = 1
         self.solid_vs_map = False
         self.color = color
         self.alpha = alpha
         self.vanishs_after_time: bool = duration > 0
         self.to_filter = to_filter
+        self._cameras = (
+            cameras if (cameras is not None and cameras) else ["C_DISPLAY"]
+        )
 
     def update(self, elapsed_time: float, target: Dynamic = None):
         if self.vanishs_after_time:
@@ -29,8 +36,17 @@ class ColorizeScreen(Projectile):
 
         # self.sprite.update(elapsed_time, self.facing_direction, self.graphic_state)
 
-    def draw_self(self, ox: float, oy: float):
-        color = Color(self.color.red, self.color.green, self.color.blue, self.alpha)
-        self.engine.backend.fill_rect(
-            self.px, self.py, self.engine.backend.render_width, self.engine.backend.render_height, color, draw_to_filter=self.to_filter
+    def draw_self(self, ox: float, oy: float, camera_name=None):
+        color = Color(
+            self.color.red, self.color.green, self.color.blue, self.alpha
         )
+        if camera_name in self._cameras:
+            self.engine.backend.fill_rect(
+                self.px,
+                self.py,
+                self.engine.backend.render_width,
+                self.engine.backend.render_height,
+                color,
+                camera_name,
+                draw_to_filter=self.to_filter,
+            )

mima/objects/effects/debug_box.py

@@ -0,0 +1,124 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+from ...types.alignment import Alignment
+from ...util.colors import DARK_RED, TRANS_LIGHT_RED
+from ...util.constants import SMALL_FONT_HEIGHT, SMALL_FONT_WIDTH
+from ..projectile import Projectile
+
+if TYPE_CHECKING:
+    from ...util.colors import Color
+    from ..dynamic import Dynamic
+
+
+class DynamicDebugBox(Projectile):
+    def __init__(
+        self,
+        follow: Dynamic,
+        color: Color = TRANS_LIGHT_RED,
+        n_frames=1,
+        ids=None,
+    ) -> None:
+        super().__init__(
+            0, 0, 0, 0, 0, Alignment.NEUTRAL, follow.tilemap, "DynamicDebugBox"
+        )
+        self.layer = 2
+        self.sprite = None
+
+        self._follow: Dynamic = follow
+        self._color: Color = color
+        self._n_frames: int = n_frames
+        self._ids: List[int] = ids if ids is not None else follow.chunks
+
+    def update(self, elapsed_time: float, target: Dynamic = None):
+        if self._n_frames >= 0:
+            if self._n_frames == 0:
+                self.kill()
+
+            self._n_frames -= 1
+
+    def draw_self(self, ox, oy, camera_name):
+        ppx = (
+            self._follow.px - ox + self._follow.hitbox_px
+        ) * self.engine.rtc.tile_width
+        ppy = (
+            self._follow.py - oy + self._follow.hitbox_py
+        ) * self.engine.rtc.tile_height
+        pwidth = self._follow.hitbox_width * self.engine.rtc.tile_width
+        pheight = self._follow.hitbox_height * self.engine.rtc.tile_height
+        self.engine.backend.fill_rect(
+            ppx, ppy, pwidth, pheight, self._color, camera_name
+        )
+        txt = ""
+        for i in self._ids:
+            txt += f"{i} "
+
+        if txt:
+            txt = txt.strip()
+            text_pw = len(txt) * SMALL_FONT_WIDTH + 1
+            text_ph = SMALL_FONT_HEIGHT + 1
+            text_ppx = ppx + pwidth / 2 - text_pw / 2
+            text_ppy = ppy + pheight / 2 - text_ph / 2
+            self.engine.backend.fill_rect(
+                text_ppx - 1,
+                text_ppy - 1,
+                text_pw + 1,
+                text_ph + 1,
+                DARK_RED,
+                camera_name,
+            )
+            self.engine.backend.draw_small_text(
+                txt, text_ppx, text_ppy, camera_name=camera_name
+            )
+
+
+class StaticDebugBox(Projectile):
+    def __init__(self, px, py, width, height, color, n_frames=1, ids=None):
+        super().__init__(
+            px, py, 0, 0, 0, Alignment.NEUTRAL, None, "StaticDebugBox"
+        )
+        self.layer = 2
+        self._color = color
+        self._n_frames = n_frames
+        self._px = px
+        self._py = py
+        self._width = width
+        self._height = height
+        self._ids: List[int] = ids if ids is not None else []
+
+    def update(self, elapsed_time: float, target: Dynamic = None):
+        if self._n_frames <= 0:
+            self.kill()
+
+        self._n_frames -= 1
+
+    def draw_self(self, ox, oy, camera_name):
+        ppx = (self._px - ox) * self.engine.rtc.tile_width
+        ppy = (self._py - oy) * self.engine.rtc.tile_height
+        pwidth = self._width * self.engine.rtc.tile_width
+        pheight = self._height * self.engine.rtc.tile_height
+        self.engine.backend.fill_rect(
+            ppx, ppy, pwidth, pheight, self._color, camera_name
+        )
+        txt = ""
+        for i in self._ids:
+            txt += f"{i} "
+
+        if txt:
+            txt = txt.strip()
+            text_pw = len(txt) * self.engine.rtc.small_font_width + 1
+            text_ph = self.engine.rtc.small_font_height + 1
+            text_ppx = ppx + pwidth / 2 - text_pw / 2
+            text_ppy = ppy + pheight / 2 - text_ph / 2
+            self.engine.backend.fill_rect(
+                text_ppx - 1,
+                text_ppy - 1,
+                text_pw + 1,
+                text_ph + 1,
+                self.engine.rtc.color_dark_red,
+                camera_name,
+            )
+            self.engine.backend.draw_small_text(
+                txt, text_ppx, text_ppy, camera_name=camera_name
+            )

mima/objects/effects/light.py

@@ -2,8 +2,6 @@ from typing import List
 
 from ...types.alignment import Alignment
 from ...types.blend import Blend
-from ...util.colors import BLACK, DARK_GREY, VERY_LIGHT_GREY, WHITE
-from ...util.constants import TILE_HEIGHT, TILE_WIDTH
 from ..dynamic import Dynamic
 from ..projectile import Projectile
 
@@ -16,12 +14,15 @@ class Light(Projectile):
         fixed_size: bool = False,
         update_from_target: bool = False,
     ):
-        super().__init__(0, 0, 0, 0, 0, Alignment.GOOD)
+        super().__init__(
+            0, 0, 0, 0, 0, Alignment.GOOD, follow.tilemap, "Light"
+        )
         self.layer = 1
         self.sprite.name = "light_small"
         self.sprite.width = 48
         self.sprite.height = 48
         self.solid_vs_map = False
+        # self.moves_on_collision = False
         self._follow: Dynamic = follow
         self._fixed_size: bool = fixed_size
         self._update_from_target: bool = update_from_target
@@ -35,14 +36,14 @@ class Light(Projectile):
 
         self._prepare_light(max_size)
 
-        # print(f"Light({id(self)}, {self.layer}, {self.sprite.name}, {self.sprite.width, self.sprite.height}, {self._follow}, {self._max_size}, {self._fixed_size}, {self._sizes}, {self._size_idx})")
-
     def update(self, elapsed_time: float, target: Dynamic = None):
         self.px = (
-            self._follow.px + self._follow.sprite.width / TILE_WIDTH * 0.5
+            self._follow.px
+            + self._follow.sprite.width / self.engine.rtc.tile_width * 0.5
         )
         self.py = (
-            self._follow.py + self._follow.sprite.height / TILE_HEIGHT * 0.5
+            self._follow.py
+            + self._follow.sprite.height / self.engine.rtc.tile_height * 0.5
         )
 
         rad = self._follow.light_radius()
@@ -60,41 +61,31 @@ class Light(Projectile):
             self._timer += self._timer_reset
             self._size_idx = (self._size_idx + 1) % len(self._sizes)
 
-        # self.sprite.update(elapsed_time, self.facing_direction, self.graphic_state)
-
-    def draw_self(self, ox: float, oy: float):
-        # color = Color(self.color.red, self.color.green, self.color.blue, self.alpha)
-        # self.engine.backend.fill_rect(self.px, self.py, WIDTH, HEIGHT, color)
-        # self.engine.backend.draw_partial_sprite(
-        #     (self.px - ox) * TILE_WIDTH,
-        #     (self.py - oy) * TILE_WIDTH,
-        #     self.sprite.name,
-        #     0,
-        #     0,
-        #     self.sprite.width,
-        #     self.sprite.height,
-        #     draw_to_filter=True,
-        # )
-        # print(f"Drawing light {self} of {self._follow} at {(self.px - ox + self._follow.extra_ox) * TILE_WIDTH,(self.py - oy + self._follow.extra_oy) * TILE_HEIGHT}")
+    def draw_self(self, ox: float, oy: float, camera_name: str):
         self.engine.backend.fill_circle(
-            (self.px - ox + self._follow.extra_ox) * TILE_WIDTH,
-            (self.py - oy + self._follow.extra_oy) * TILE_HEIGHT,
+            (self.px - ox + self._follow.extra_ox)
+            * self.engine.rtc.tile_width,
+            (self.py - oy + self._follow.extra_oy)
+            * self.engine.rtc.tile_height,
             self._sizes[self._size_idx] * 0.65,  # 0.3125 *
-            DARK_GREY,
+            self.engine.rtc.color_dark_grey,
+            camera_name,
             blend_mode=Blend.SUB,
             draw_to_filter=True,
         )
         self.engine.backend.fill_circle(
-            (self.px - ox + self._follow.extra_ox) * TILE_WIDTH,
-            (self.py - oy + self._follow.extra_oy) * TILE_HEIGHT,
+            (self.px - ox + self._follow.extra_ox)
+            * self.engine.rtc.tile_width,
+            (self.py - oy + self._follow.extra_oy)
+            * self.engine.rtc.tile_height,
             self._sizes[self._size_idx] * 0.5,  # 0.3125 *
-            VERY_LIGHT_GREY,
+            self.engine.rtc.color_very_light_grey,
+            camera_name,
             blend_mode=Blend.SUB,
             draw_to_filter=True,
         )
 
     def _prepare_light(self, max_size):
-
         self._max_size = max_size
         self._sizes = [max_size]
         if not self._fixed_size:

mima/objects/effects/show_sprite.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ...types.alignment import Alignment
+from ..projectile import Projectile
+
+if TYPE_CHECKING:
+    from ...maps.tilemap import Tilemap
+    from ..sprite import Sprite
+
+
+class ShowSprite(Projectile):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        sprite: Sprite,
+        tilemap: Tilemap,
+        layer: int = 0,
+        dyn_id: int = 0,
+    ):
+        super().__init__(
+            px, py, 0.0, 0.0, 0.0, Alignment.NEUTRAL, tilemap, "SpriteEffect"
+        )
+
+        self.layer = layer
+        self.sprite: Sprite = sprite
+
+    def update(self, elapsed_time: float):
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+    def draw_self(self, ox: float, oy: float, camera_name: str):
+        if self.sprite is None:
+            return
+
+        self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)

mima/objects/effects/walking_on_grass.py

@@ -6,7 +6,9 @@ from ..projectile import Projectile
 
 class WalkingOnGrass(Projectile):
     def __init__(self, follow: Dynamic):
-        super().__init__(follow.px, follow.py, 0, 0, 1.0, follow.alignment)
+        super().__init__(
+            follow.px, follow.py, 0, 0, 1.0, follow.alignment, follow.tilemap
+        )
         self.layer = 0
         self.sprite.name = "simple_sheet"
         self.sprite.ox = 32
@@ -17,22 +19,38 @@ class WalkingOnGrass(Projectile):
         self._follow = follow
         self.renew: bool = True
         self.solid_vs_map = False
+        # self.moves_on_collision = False
 
     def update(self, elapsed_time: float, target: Dynamic = None):
         if not self.renew:
             self.kill()
 
-        self.px = self._follow.px
-        self.py = self._follow.py
+        self.px = (
+            self._follow.px
+            + (self._follow.sprite.width - self.sprite.width)
+            / 2
+            / self.engine.rtc.tile_width
+        )
+        self.py = (
+            self._follow.py
+            + (self._follow.sprite.height - self.sprite.height)
+            / self.engine.rtc.tile_height
+        )
 
         if self._follow.graphic_state == GraphicState.STANDING:
             elapsed_time = 0
-        self.sprite.update(elapsed_time, Direction.SOUTH, GraphicState.STANDING)
+        self.sprite.update(
+            elapsed_time, Direction.SOUTH, GraphicState.STANDING
+        )
 
         self.renew = False
 
-    def draw_self(self, ox: float, oy: float):
-        if self.sprite.name is None or self.sprite.name == "" or self.redundant:
+    def draw_self(self, ox: float, oy: float, camera_name):
+        if (
+            self.sprite.name is None
+            or self.sprite.name == ""
+            or self.redundant
+        ):
             return
 
-        self.sprite.draw_self(self.px - ox, self.py - oy)
+        self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)

mima/objects/effects/walking_on_water.py

@@ -22,20 +22,31 @@ class WalkingOnWater(WalkingOnGrass):
             self.kill()
 
         self.px = (
-            self._follow.px + self._follow.sprite.width / 2 - self.sprite.width / 2
+            self._follow.px
+            + (self._follow.sprite.width - self.sprite.width)
+            / 2
+            / self.engine.rtc.tile_width
         )
         self.py = (
-            self._follow.py + self._follow.sprite.height / 2 - self.sprite.width / 2
+            self._follow.py
+            + (self._follow.sprite.height - self.sprite.height)
+            / self.engine.rtc.tile_height
         )
 
         if self._follow.graphic_state == GraphicState.STANDING:
             elapsed_time = 0
-        self.sprite.update(elapsed_time, Direction.SOUTH, GraphicState.STANDING)
+        self.sprite.update(
+            elapsed_time, Direction.SOUTH, GraphicState.STANDING
+        )
 
         self.renew = False
 
-    def draw_self(self, ox: float, oy: float):
-        if self.sprite.name is None or self.sprite.name == "" or self.redundant:
+    def draw_self(self, ox: float, oy: float, camera_name: str):
+        if (
+            self.sprite.name is None
+            or self.sprite.name == ""
+            or self.redundant
+        ):
             return
 
-        self.sprite.draw_self(self.px - ox, self.py - oy)
+        self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)

mima/objects/loader.py

@@ -1,7 +1,11 @@
+from __future__ import annotations
+
 import logging
+from typing import TYPE_CHECKING
 
 from ..types.object import ObjectType
-from ..util.constants import TILE_HEIGHT, TILE_WIDTH
+from .world.color_gate import ColorGate
+from .world.color_switch import ColorSwitch
 from .world.container import Container
 from .world.floor_switch import FloorSwitch
 from .world.gate import Gate
@@ -9,17 +13,20 @@ from .world.light_source import LightSource
 from .world.logic_gate import LogicGate
 from .world.movable import Movable
 from .world.oneway import Oneway
-from .world.color_switch import ColorSwitch
-from .world.color_gate import ColorGate
 
 # from .world.pickup import Pickup
 from .world.switch import Switch
 from .world.teleport import Teleport
 
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+
 LOG = logging.getLogger(__name__)
 
 
 class ObjectLoader:
+    engine: MimaEngine
+
     def __init__(self, object_dispatcher, creature_dispatcher):
         self._base_dispatcher = {
             "color_switch": ColorSwitch.load_from_tiled_object,
@@ -42,10 +49,10 @@ class ObjectLoader:
     def populate_dynamics(self, tilemap, dynamics):
         # self._current_map = tilemap
         for obj in tilemap.objects:
-            px = obj.px / TILE_WIDTH
-            py = obj.py / TILE_HEIGHT
-            width = max(obj.width / TILE_WIDTH, 1.0)
-            height = max(obj.height / TILE_HEIGHT, 1.0)
+            px = obj.px / self.engine.rtc.tile_width
+            py = obj.py / self.engine.rtc.tile_height
+            width = max(obj.width / self.engine.rtc.tile_width, 1.0)
+            height = max(obj.height / self.engine.rtc.tile_height, 1.0)
 
             LOG.debug(
                 f"Loading object {obj.name} ({obj.object_id}): {obj.type}) "
@@ -58,13 +65,14 @@ class ObjectLoader:
 
             try:
                 dynamics.extend(
-                    dispatcher[obj.type](obj, px, py, width, height)
+                    dispatcher[obj.type](obj, px, py, width, height, tilemap)
                 )
             except (KeyError, ValueError):
                 LOG.exception(
-                    f"Failed to load '{obj.name}' ({obj.object_id}: {obj.type})"
+                    f"Failed to load '{obj.name}' ({obj.object_id}: "
+                    f"{obj.type})"
                 )
-                raise
+                # raise
 
         # Connect listener IDs to actual listeners
         for dyn in dynamics:
@@ -90,14 +98,17 @@ class ObjectLoader:
                                         f"Logic Gate {listener.dyn_id}"
                                     )
 
-    def load_creature_from_tiled_object(self, obj, px, py, width, height):
+    def load_creature_from_tiled_object(
+        self, obj, px, py, width, height, tilemap
+    ):
         creature_type = obj.get_string("creature_type")
         try:
             return self._cstm_creature_dispatcher[creature_type](
-                obj, px, py, width, height
+                obj, px, py, width, height, tilemap
             )
         except (KeyError, ValueError):
             LOG.exception(
                 f"Failed to load '{obj.name}' ({obj.object_id}: {obj.type})"
             )
-            raise
+            # raise
+            return []

mima/objects/projectile.py

@@ -1,8 +1,15 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from ..types.alignment import Alignment
 from ..types.damage import Damage
 from ..types.object import ObjectType
 from .dynamic import Dynamic
 
+if TYPE_CHECKING:
+    from ..maps.tilemap import Tilemap
+
 
 class Projectile(Dynamic):
     def __init__(
@@ -13,9 +20,10 @@ class Projectile(Dynamic):
         vy: float,
         duration: float,
         alignment: Alignment,
+        tilemap: Tilemap = None,
         name: str = "Projectile",
     ):
-        super().__init__(name, px, py)
+        super().__init__(px, py, name, tilemap)
 
         self.type = ObjectType.PROJECTILE
         self.vx = vx
@@ -31,6 +39,7 @@ class Projectile(Dynamic):
         self.one_hit = False
         self.inherit_pos = False
         self.gravity = False
+        self.moves_on_collision = True
         self.change_solid_vs_map_timer = 0
         self.dtype = Damage.BODY
         self.damage = 0
@@ -47,12 +56,13 @@ class Projectile(Dynamic):
                 self.change_solid_vs_map_timer = 0
 
         self.speed = self.attributes.speed
-
+        # if "body" not in self.name:
+        #     print(self.name, self.pz)
         self.sprite.update(
             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 (
             self.sprite.name is None
             or self.sprite.name == ""
@@ -60,7 +70,7 @@ class Projectile(Dynamic):
         ):
             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_death(self) -> bool:
         if self.spawn_on_death:
@@ -69,9 +79,11 @@ class Projectile(Dynamic):
                     if self.inherit_pos:
                         do.px = self.px
                         do.py = self.py
-                    self.engine.scene.add_projectile(do)
+                    self.engine.get_view().add_projectile(
+                        do, self.tilemap.name
+                    )
                 else:
-                    self.engine.scene.add_dynamic(do)
+                    self.engine.get_view().add_dynamic(do, self.tilemap.name)
 
         return False
 
@@ -84,3 +96,6 @@ class Projectile(Dynamic):
                     do.kill()
         self.kill()
         return True
+
+    def __str__(self):
+        return f"P({self.name}, {self.dyn_id})"

mima/objects/sprite.py

@@ -8,20 +8,18 @@ from ..util.constants import (
     DEFAULT_GRAPHIC_TIMER_WALKING,
     DEFAULT_SPRITE_HEIGHT,
     DEFAULT_SPRITE_WIDTH,
-    TILE_HEIGHT,
-    TILE_WIDTH,
 )
 
 
 class Sprite:
     engine = None
 
-    def __init__(self, name: str = ""):
+    def __init__(self, name: str = "", *, ox=0, oy=0, width=0, height=0):
         self.name = name
         self.ox: int = 0
         self.oy: int = 0
-        self.width: int = DEFAULT_SPRITE_WIDTH
-        self.height: int = DEFAULT_SPRITE_HEIGHT
+        self.width: int = DEFAULT_SPRITE_WIDTH if width == 0 else width
+        self.height: int = DEFAULT_SPRITE_HEIGHT if height == 0 else height
         self.num_frames: int = 1
         self.frame_index: int = 0
 
@@ -74,7 +72,7 @@ class Sprite:
         self.last_direction = direction
         self.last_graphic_state = graphic_state
 
-    def draw_self(self, px: float, py: float):
+    def draw_self(self, px: float, py: float, camera_name: str = "display"):
         if self.name == "":
             return
 
@@ -96,13 +94,14 @@ class Sprite:
             sheet_oy = (self.oy + state_value) * self.height
 
         self.engine.backend.draw_partial_sprite(
-            px * TILE_WIDTH,
-            py * TILE_HEIGHT,
+            px * self.engine.rtc.tile_width,
+            py * self.engine.rtc.tile_height,
             self.name,
             sheet_ox,
             sheet_oy,
             self.width,
             self.height,
+            camera_name,
         )
 
     def reset(self):

mima/objects/world/color_gate.py

@@ -21,20 +21,22 @@ class ColorGate(Gate):
         graphic_state: GraphicState,
         facing_direction: Direction,
         color: GateColor,
+        tilemap=None,
         dyn_id: int = -1,
         name: str = "ColorGate",
     ):
         super().__init__(
             px,
             py,
+            name,
             tileset_name,
             image_name,
             sprite_name,
             graphic_state,
             facing_direction,
             False,
+            tilemap,
             dyn_id,
-            name,
         )
         self.color = color
         self.type = ObjectType.COLOR_GATE
@@ -47,7 +49,7 @@ class ColorGate(Gate):
         return False
 
     @staticmethod
-    def load_from_tiled_object(obj, px, py, width, height):
+    def load_from_tiled_object(obj, px, py, width, height, tilemap):
         gate = ColorGate(
             px=px,
             py=py,
@@ -61,6 +63,7 @@ class ColorGate(Gate):
                 obj.get_string("facing_direction", "south").upper()
             ],
             color=GateColor[obj.get_string("color", "red").upper()],
+            tilemap=tilemap,
             dyn_id=obj.object_id,
             name=obj.name,
         )