mima-engine 0.4.0__py3-none-any.whl

mima/objects/effects/debug_box.py

@@ -0,0 +1,133 @@
+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,
+            "DynamicDebugBox",
+            duration=0.0,
+            alignment=Alignment.NEUTRAL,
+            tilemap=follow.tilemap,
+        )
+        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,
+            "StaticDebugBox",
+            duration=0.0,
+            alignment=Alignment.NEUTRAL,
+        )
+        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

@@ -0,0 +1,103 @@
+from typing import List
+
+from ...types.alignment import Alignment
+from ...types.blend import Blend
+from ..dynamic import Dynamic
+from ..projectile import Projectile
+
+
+class Light(Projectile):
+    def __init__(
+        self,
+        follow: Dynamic,
+        max_size: int = 64,
+        fixed_size: bool = False,
+        update_from_target: bool = False,
+    ):
+        super().__init__(
+            0,
+            0,
+            name="Light",
+            tilemap=follow.tilemap,
+            duration=0,
+            alignment=Alignment.GOOD,
+        )
+        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
+
+        self._timer: float = 0.2
+        self._timer_reset: float = 0.2
+        self._size_idx: int = 0
+
+        self._sizes: List[int]
+        self._max_size: int
+
+        self._prepare_light(max_size)
+
+    def update(self, elapsed_time: float, target: Dynamic = None):
+        self.px = (
+            self._follow.px
+            + self._follow.sprite.width / self.engine.rtc.tile_width * 0.5
+        )
+        self.py = (
+            self._follow.py
+            + self._follow.sprite.height / self.engine.rtc.tile_height * 0.5
+        )
+
+        rad = self._follow.light_radius()
+        if self._max_size != rad:
+            self._prepare_light(rad)
+
+        if self._follow.redundant:
+            self.kill()
+
+        if self._fixed_size:
+            return
+
+        self._timer -= elapsed_time
+        if self._timer <= 0.0:
+            self._timer += self._timer_reset
+            self._size_idx = (self._size_idx + 1) % len(self._sizes)
+
+    def draw_self(self, ox: float, oy: float, camera_name: str):
+        self.engine.backend.fill_circle(
+            (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 *
+            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)
+            * 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 *
+            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:
+            self._sizes.extend(
+                [
+                    int(max_size * 0.97),
+                    int(max_size * 0.94),
+                    int(max_size * 0.97),
+                ]
+            )

mima/objects/effects/show_sprite.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+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,
+        name: str = "ShowSprite",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = 0,
+        layer: int = 0,
+    ):
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+            vx=0.0,
+            vy=0.0,
+            duration=0.0,
+            alignment=Alignment.NEUTRAL,
+        )
+
+        self.layer = layer
+        self.draw_to_ui: bool = False
+
+    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

@@ -0,0 +1,70 @@
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
+from ..dynamic import Dynamic
+from ..projectile import Projectile
+
+
+class WalkingOnGrass(Projectile):
+    def __init__(
+        self,
+        follow: Dynamic,
+        name: str = "WalkingOnGrass",
+        sprite_name: str = "walking_on_grass",
+    ):
+        super().__init__(
+            follow.px,
+            follow.py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=follow.tilemap,
+            vx=0,
+            vy=0,
+            duration=1.0,
+            alignment=follow.alignment,
+        )
+        self.layer = 0
+        # self.sprite.name = "simple_sheet"
+        # self.sprite.ox = 32
+        # self.sprite.oy = 10
+        # self.sprite.num_frames = 2
+        # self.sprite.timer = 0.2
+        # self.sprite.timer_reset = 0.2
+        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._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.WALKING:
+            self.graphic_state = GraphicState.WALKING
+        else:
+            self.graphic_state = GraphicState.STANDING
+            # elapsed_time = 0
+        self.sprite.update(elapsed_time, Direction.SOUTH, self.graphic_state)
+
+        self.renew = False
+
+    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, camera_name)

mima/objects/effects/walking_on_water.py

@@ -0,0 +1,57 @@
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
+from ..dynamic import Dynamic
+from .walking_on_grass import WalkingOnGrass
+
+
+class WalkingOnWater(WalkingOnGrass):
+    def __init__(
+        self,
+        follow: Dynamic,
+        name: str = "WalkingOnWater",
+        sprite_name: str = "walking_on_water",
+    ):
+        super().__init__(follow, name, sprite_name)
+        # self.sprite.name = "simple_sheet"
+        # self.sprite.ox = 32
+        # self.sprite.oy = 9
+        # self.sprite.num_frames = 2
+        # self.sprite.timer = 0.2
+        # self.sprite.timer_reset = 0.2
+        self._follow = follow
+        self.renew: bool = True
+        self.solid_vs_map = False
+
+    # def update(self, elapsed_time: float, target: Dynamic = None):
+    #     if not self.renew:
+    #         self.kill()
+
+    #     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.renew = False
+
+    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, camera_name)

mima/objects/loader.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING
+
+from ..types.object import ObjectType
+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
+from .world.light_source import LightSource
+from .world.logic_gate import LogicGate
+from .world.movable import Movable
+from .world.oneway import Oneway
+from .world.pickup import Pickup
+
+# 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,
+            "color_gate": ColorGate.load_from_tiled_object,
+            "container": Container.load_from_tiled_object,
+            "floor_switch": FloorSwitch.load_from_tiled_object,
+            "gate": Gate.load_from_tiled_object,
+            "light_source": LightSource.load_from_tiled_object,
+            "logic_gate": LogicGate.load_from_tiled_object,
+            "movable": Movable.load_from_tiled_object,
+            "oneway": Oneway.load_from_tiled_object,
+            "pickup": Pickup.load_from_tiled_object,
+            "switch": Switch.load_from_tiled_object,
+            "teleport": Teleport.load_from_tiled_object,
+            "creature": self.load_creature_from_tiled_object,
+        }
+        self._cstm_object_dispatcher = object_dispatcher
+        self._cstm_creature_dispatcher = creature_dispatcher
+        # self._current_map = None
+
+    def populate_dynamics(self, tilemap, dynamics):
+        # self._current_map = tilemap
+        for obj in tilemap.objects:
+            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}) "
+                f"at {px, py}."
+            )
+            if obj.type in self._cstm_object_dispatcher:
+                dispatcher = self._cstm_object_dispatcher
+            else:
+                dispatcher = self._base_dispatcher
+
+            try:
+                dynamics.extend(
+                    dispatcher[obj.type](obj, px, py, width, height, tilemap)
+                )
+            except (KeyError, ValueError):
+                LOG.exception(
+                    f"Failed to load '{obj.name}' ({obj.object_id}: " f"{obj.type})"
+                )
+                raise
+
+        # Connect listener IDs to actual listeners
+        for dyn in dynamics:
+            if dyn.type in [
+                ObjectType.SWITCH,
+                ObjectType.FLOOR_SWITCH,
+                ObjectType.LOGIC_GATE,
+            ]:
+                for listener_id in dyn.listener_ids:
+                    for listener in dynamics:
+                        if listener.dyn_id == listener_id:
+                            dyn.listeners.append(listener)
+
+                            if listener.type == ObjectType.LOGIC_GATE:
+                                if listener.input_id1 == -1:
+                                    listener.input_id1 = dyn.dyn_id
+                                elif listener.input_id2 == -1:
+                                    listener.input_id2 = dyn.dyn_id
+                                else:
+                                    LOG.warning(
+                                        f"Object with ID {dyn.dyn_id} "
+                                        "has no free input port at "
+                                        f"Logic Gate {listener.dyn_id}"
+                                    )
+
+    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, tilemap
+            )
+        except (KeyError, ValueError):
+            LOG.exception(f"Failed to load '{obj.name}' ({obj.object_id}: {obj.type})")
+            # raise
+            return []

mima/objects/projectile.py

@@ -0,0 +1,111 @@
+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__(
+        self,
+        px: float,
+        py: float,
+        name: str = "Projectile",
+        *,
+        sprite_name: str = "",
+        tilemap: Tilemap = None,
+        dyn_id: int = 1000,
+        vx: float = 0.0,
+        vy: float = 0.0,
+        duration: float,
+        alignment: Alignment,
+    ):
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+        )
+
+        self.type = ObjectType.PROJECTILE
+        self.vx = vx
+        self.vy = vy
+        self.pz = 0.5
+        self.duration = duration
+        self.alignment = alignment
+
+        self.solid_vs_dyn = False
+        self.solid_vs_map = True
+        self.is_projectile = True  # redundant
+        self.attackable = False
+        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
+
+    def update(self, elapsed_time: float, target: Dynamic = None):
+        self.duration -= elapsed_time
+        if self.duration <= 0.0:
+            self.kill()
+
+        if self.change_solid_vs_map_timer > 0:
+            self.change_solid_vs_map_timer -= elapsed_time
+            if self.change_solid_vs_map_timer <= 0:
+                self.solid_vs_map = not self.solid_vs_map
+                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, camera_name: str = "display"):
+        if (
+            self.sprite.name is None
+            or self.sprite.name == ""
+            or self.redundant
+        ):
+            return
+
+        self.sprite.draw_self(self.px - ox, self.py - oy, camera_name)
+
+    def on_death(self) -> bool:
+        if self.spawn_on_death:
+            for do in self.spawn_on_death:
+                if do.type == ObjectType.PROJECTILE:
+                    if self.inherit_pos:
+                        do.px = self.px
+                        do.py = self.py
+                    self.engine.get_view().add_projectile(
+                        do, self.tilemap.name
+                    )
+                else:
+                    self.engine.get_view().add_dynamic(do, self.tilemap.name)
+
+        return False
+
+    def cancel(self):
+        if self.spawn_on_death:
+            for do in self.spawn_on_death:
+                if do.type == ObjectType.PROJECTILE:
+                    do.cancel()  # Projectile will kill itself
+                else:
+                    do.kill()
+        self.kill()
+        return True
+
+    def __str__(self):
+        return f"P({self.name}, {self.dyn_id})"