mima-engine 0.1.0__py3-none-any.whl

mima/objects/effects/light.py

@@ -0,0 +1,107 @@
+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
+
+
+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, 0, 0, 0, Alignment.GOOD)
+        self.layer = 1
+        self.sprite.name = "light_small"
+        self.sprite.width = 48
+        self.sprite.height = 48
+        self.solid_vs_map = 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)
+
+        # 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.py = (
+            self._follow.py + self._follow.sprite.height / 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)
+
+        # 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}")
+        self.engine.backend.fill_circle(
+            (self.px - ox + self._follow.extra_ox) * TILE_WIDTH,
+            (self.py - oy + self._follow.extra_oy) * TILE_HEIGHT,
+            self._sizes[self._size_idx] * 0.65,  # 0.3125 *
+            DARK_GREY,
+            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._sizes[self._size_idx] * 0.5,  # 0.3125 *
+            VERY_LIGHT_GREY,
+            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/walking_on_grass.py

@@ -0,0 +1,38 @@
+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):
+        super().__init__(follow.px, follow.py, 0, 0, 1.0, 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
+
+    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
+
+        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):
+        if self.sprite.name is None or self.sprite.name == "" or self.redundant:
+            return
+
+        self.sprite.draw_self(self.px - ox, self.py - oy)

mima/objects/effects/walking_on_water.py

@@ -0,0 +1,41 @@
+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):
+        super().__init__(follow)
+        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 / 2 - self.sprite.width / 2
+        )
+        self.py = (
+            self._follow.py + self._follow.sprite.height / 2 - self.sprite.width / 2
+        )
+
+        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):
+        if self.sprite.name is None or self.sprite.name == "" or self.redundant:
+            return
+
+        self.sprite.draw_self(self.px - ox, self.py - oy)

mima/objects/loader.py

@@ -0,0 +1,103 @@
+import logging
+
+from ..types.object import ObjectType
+from ..util.constants import TILE_HEIGHT, TILE_WIDTH
+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.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
+
+LOG = logging.getLogger(__name__)
+
+
+class ObjectLoader:
+    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,
+            "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 / TILE_WIDTH
+            py = obj.py / TILE_HEIGHT
+            width = max(obj.width / TILE_WIDTH, 1.0)
+            height = max(obj.height / 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)
+                )
+            except (KeyError, ValueError):
+                LOG.exception(
+                    f"Failed to load '{obj.name}' ({obj.object_id}: {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):
+        creature_type = obj.get_string("creature_type")
+        try:
+            return self._cstm_creature_dispatcher[creature_type](
+                obj, px, py, width, height
+            )
+        except (KeyError, ValueError):
+            LOG.exception(
+                f"Failed to load '{obj.name}' ({obj.object_id}: {obj.type})"
+            )
+            raise

mima/objects/projectile.py

@@ -0,0 +1,86 @@
+from ..types.alignment import Alignment
+from ..types.damage import Damage
+from ..types.object import ObjectType
+from .dynamic import Dynamic
+
+
+class Projectile(Dynamic):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        vx: float,
+        vy: float,
+        duration: float,
+        alignment: Alignment,
+        name: str = "Projectile",
+    ):
+        super().__init__(name, px, py)
+
+        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.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
+
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+    def draw_self(self, ox: float, oy: float):
+        if (
+            self.sprite.name is None
+            or self.sprite.name == ""
+            or self.redundant
+        ):
+            return
+
+        self.sprite.draw_self(self.px - ox, self.py - oy)
+
+    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.scene.add_projectile(do)
+                else:
+                    self.engine.scene.add_dynamic(do)
+
+        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

mima/objects/sprite.py

@@ -0,0 +1,110 @@
+from ..types.direction import Direction
+from ..types.graphic_state import GraphicState
+from ..util.constants import (
+    DEFAULT_GRAPHIC_TIMER,
+    DEFAULT_GRAPHIC_TIMER_DAMAGED,
+    DEFAULT_GRAPHIC_TIMER_DEAD,
+    DEFAULT_GRAPHIC_TIMER_STANDING,
+    DEFAULT_GRAPHIC_TIMER_WALKING,
+    DEFAULT_SPRITE_HEIGHT,
+    DEFAULT_SPRITE_WIDTH,
+    TILE_HEIGHT,
+    TILE_WIDTH,
+)
+
+
+class Sprite:
+    engine = None
+
+    def __init__(self, name: str = ""):
+        self.name = name
+        self.ox: int = 0
+        self.oy: int = 0
+        self.width: int = DEFAULT_SPRITE_WIDTH
+        self.height: int = DEFAULT_SPRITE_HEIGHT
+        self.num_frames: int = 1
+        self.frame_index: int = 0
+
+        self.timer: float = 0.25
+        self.timer_reset: float = 0.5
+
+        self.last_direction: Direction = Direction.SOUTH
+        self.last_graphic_state: GraphicState = GraphicState.STANDING
+
+    def update(
+        self,
+        elapsed_time: float,
+        direction: Direction = Direction.SOUTH,
+        graphic_state: GraphicState = GraphicState.STANDING,
+    ):
+        if (
+            direction == self.last_direction
+            and graphic_state == self.last_graphic_state
+        ):
+            # Nothing has changed, normal case
+            self.timer -= elapsed_time
+
+            if self.timer <= 0.0:
+                self.timer += self.timer_reset
+                self.frame_index = (self.frame_index + 1) % self.num_frames
+
+        else:
+            # Something changed
+            if graphic_state != self.last_graphic_state:
+                # State changed
+                if graphic_state == GraphicState.STANDING:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_STANDING
+                elif graphic_state == GraphicState.WALKING:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_WALKING
+                elif graphic_state == GraphicState.DAMAGED:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_DAMAGED
+                elif graphic_state == GraphicState.DEAD:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_DEAD
+                elif graphic_state == GraphicState.PUSHING:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER_WALKING
+                else:
+                    self.timer_reset = DEFAULT_GRAPHIC_TIMER
+
+                # self.timer = self.timer_reset
+                # self.frame_index = 0
+
+            self.timer = self.timer_reset
+            self.frame_index = 0
+
+        self.last_direction = direction
+        self.last_graphic_state = graphic_state
+
+    def draw_self(self, px: float, py: float):
+        if self.name == "":
+            return
+
+        sheet_ox = sheet_oy = 0
+        state_value = self.last_graphic_state.value
+
+        if self.last_graphic_state == GraphicState.CELEBRATING:
+            sheet_ox = (self.ox + self.frame_index) * self.width
+            sheet_oy = (self.oy + state_value) * self.height
+        elif self.last_graphic_state == GraphicState.DEAD:
+            sheet_ox = (self.ox + 2 + self.frame_index) * self.width
+            sheet_oy = (self.oy + state_value) * self.height
+        else:
+            if self.last_graphic_state == GraphicState.PUSHING:
+                state_value -= 1
+            sheet_ox = (
+                self.ox + 2 * self.last_direction.value + self.frame_index
+            ) * self.width
+            sheet_oy = (self.oy + state_value) * self.height
+
+        self.engine.backend.draw_partial_sprite(
+            px * TILE_WIDTH,
+            py * TILE_HEIGHT,
+            self.name,
+            sheet_ox,
+            sheet_oy,
+            self.width,
+            self.height,
+        )
+
+    def reset(self):
+        self.frame_index = 0
+        self.timer = 0.0

mima/objects/world/color_gate.py

@@ -0,0 +1,68 @@
+from typing import 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 ..dynamic import Dynamic
+from .gate import Gate
+
+
+class ColorGate(Gate):
+
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        graphic_state: GraphicState,
+        facing_direction: Direction,
+        color: GateColor,
+        dyn_id: int = -1,
+        name: str = "ColorGate",
+    ):
+        super().__init__(
+            px,
+            py,
+            tileset_name,
+            image_name,
+            sprite_name,
+            graphic_state,
+            facing_direction,
+            False,
+            dyn_id,
+            name,
+        )
+        self.color = color
+        self.type = ObjectType.COLOR_GATE
+
+    def update(self, elapsed_time, float, target: Optional[Dynamic] = None):
+        self.open = self.engine.gate_color == self.color
+        super().update(elapsed_time, target)
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        return False
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height):
+        gate = ColorGate(
+            px=px,
+            py=py,
+            tileset_name=obj.get_string("tileset_name"),
+            image_name=obj.get_string("tileset_name"),
+            sprite_name=obj.get_string("sprite_name"),
+            graphic_state=GraphicState[
+                obj.get_string("graphic_state", "closed").upper()
+            ],
+            facing_direction=Direction[
+                obj.get_string("facing_direction", "south").upper()
+            ],
+            color=GateColor[obj.get_string("color", "red").upper()],
+            dyn_id=obj.object_id,
+            name=obj.name,
+        )
+
+        return [gate]

mima/objects/world/color_switch.py

@@ -0,0 +1,105 @@
+from typing import 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
+
+
+class ColorSwitch(Switch):
+    def __init__(
+        self,
+        px: float,
+        py: float,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: str,
+        facing_direction: Direction,
+        graphic_state: GraphicState,
+        color: GateColor,
+        initial_signal=True,
+        dyn_id=-1,
+        name="ColorSwitch",
+    ):
+
+        super().__init__(
+            px,
+            py,
+            tileset_name,
+            image_name,
+            sprite_name,
+            facing_direction,
+            graphic_state,
+            initial_signal,
+            dyn_id,
+            name,
+        )
+        self.type = ObjectType.COLOR_SWITCH
+
+        self.color = color
+        self.graphic_state = (
+            GraphicState.CLOSED
+            if color == self.engine.gate_color
+            else GraphicState.OPEN
+        )
+        # self.signal = self.graphic_state == GraphicState.CLOSED
+        self.send_initial_signal = False
+
+    def update(self, elapsed_time: float, target: Optional[Dynamic] = None):
+        self.graphic_state = (
+            GraphicState.CLOSED
+            if self.color == self.engine.gate_color
+            else GraphicState.OPEN
+        )
+        # self.signal = self.graphic_state == GraphicState.CLOSED
+        #
+        self.sprite.update(
+            elapsed_time, self.facing_direction, self.graphic_state
+        )
+
+    def on_interaction(self, target: Dynamic, nature: Nature):
+        if (
+            nature == Nature.TALK
+            and target.type == ObjectType.PLAYER
+            and self.visible
+        ):
+            if self.engine.gate_color != self.color:
+                self.engine.gate_color = self.color
+            else:
+                self.engine.gate_color = GateColor(
+                    (self.color.value + 1) % self.engine.n_gate_colors
+                )
+            self.state_changed = True
+            self.engine.audio.play_sound("switch")
+            return True
+
+        return False
+
+    @staticmethod
+    def load_from_tiled_object(obj, px, py, width, height):
+        switch = ColorSwitch(
+            px=px,
+            py=py,
+            tileset_name=obj.get_string("tileset_name"),
+            image_name=obj.get_string("tileset_name"),
+            sprite_name=obj.get_string("sprite_name"),
+            graphic_state=GraphicState[
+                obj.get_string("graphic_state", "closed").upper()
+            ],
+            facing_direction=Direction[
+                obj.get_string("facing_direction", "south").upper()
+            ],
+            color=GateColor[obj.get_string("color", "red").upper()],
+            initial_signal=False,
+            dyn_id=obj.object_id,
+            name=obj.name,
+        )
+
+        switch.sprite.width = int(width * TILE_WIDTH)
+        switch.sprite.height = int(height * TILE_HEIGHT)
+
+        return [switch]