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

mima/objects/animated_sprite.py

@@ -14,54 +14,60 @@ class AnimatedSprite:
 
     def __init__(
         self,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: Optional[str] = None,
+        # tileset_name: str,
+        # image_name: str,
+        sprite_name: str,
         graphic_state: GraphicState = GraphicState.STANDING,
         facing_direction: Direction = Direction.SOUTH,
     ):
-        self._sprite_name = (
-            tileset_name if sprite_name is None else sprite_name
-        )
-
-        self._tileset_name = tileset_name
-        self.name = image_name
-        # TODO: Handle ""
-        if tileset_name and image_name and self._sprite_name:
-            LOG.info(
-                {
-                    "operation": "load sprite",
-                    "tileset": tileset_name,
-                    "image": image_name,
-                    "sprite": self._sprite_name,
-                }
-            )
-            tileset = self.engine.assets.get_tileset(tileset_name)
-
-            self.width = tileset.tile_width
-            self.height = tileset.tile_height
 
-            self._sprites: Dict[
-                GraphicState, Dict[Direction, Dict[str, Any]]
-            ] = self._load_sprites_from_tileset(tileset, self._sprite_name)
+        self.name = sprite_name
+        self._last_direction: Direction = facing_direction
+        self._last_graphic_state: GraphicState = graphic_state
+        self.sprite_sheet = self.engine.assets.get_sprite_data(sprite_name)
 
-            self._last_direction: Direction = facing_direction
-            self._last_graphic_state: GraphicState = graphic_state
+        if self.name:
             data = self._get_data(
                 self._last_graphic_state, self._last_direction
             )
-
             self._frame_index: int = 0
             self._timer: float = data["duration"][0]
+            self._ox = data["ox"][0]
+            self._oy = data["oy"][0]
+            self._image_name = data["image"][0]
+            self.width = data["width"][0]
+            self.height = data["height"][0]
         else:
-            LOG.debug(
-                "Sprite information uncomplete. Tileset=%s, Image=%s, Sprite="
-                "%s. Will continue without sprite.",
-                tileset_name,
-                image_name,
-                self._sprite_name,
-            )
-            self.name = self._tileset_name = self._sprite_name = ""
+            self.width = self.engine.rtc.tile_width
+            self.height = self.engine.rtc.tile_height
+        # # TODO: Handle ""
+        # if tileset_name and image_name and self._sprite_name:
+        #     LOG.info(
+        #         {
+        #             "operation": "load sprite",
+        #             "tileset": tileset_name,
+        #             "image": image_name,
+        #             "sprite": self._sprite_name,
+        #         }
+        #     )
+        #     tileset = self.engine.assets.get_tileset(tileset_name)
+
+        #     self.width = tileset.tile_width
+        #     self.height = tileset.tile_height
+
+        #     self._sprites: Dict[GraphicState, Dict[Direction, Dict[str, Any]]] = (
+        #         self._load_sprites_from_tileset(tileset, self._sprite_name)
+        #     )
+
+        # else:
+        #     LOG.debug(
+        #         "Sprite information uncomplete. Tileset=%s, Image=%s, Sprite="
+        #         "%s. Will continue without sprite.",
+        #         tileset_name,
+        #         image_name,
+        #         self._sprite_name,
+        #     )
+        #     self.name = self._tileset_name = self._sprite_name = ""
 
     def update(
         self,
@@ -73,13 +79,6 @@ class AnimatedSprite:
             return
 
         data = self._get_data(graphic_state, direction)
-        # try:
-        #     self._timer_reset = data["duration"][self._frame_index]
-        # except KeyError as err:
-        #     LOG.exception(
-        #         f"Data of {self._tileset_name, self.name} is "
-        #         f"malformed: {data}"
-        #     )
 
         if (
             direction == self._last_direction
@@ -92,7 +91,11 @@ class AnimatedSprite:
                     data["duration"]
                 )
                 self._timer += data["duration"][self._frame_index]
-
+                self._ox = data["ox"][self._frame_index]
+                self._oy = data["oy"][self._frame_index]
+                self._image_name = data["image"][self._frame_index]
+                self.width = data["width"][self._frame_index]
+                self.height = data["height"][self._frame_index]
         else:
             self._frame_index = 0
             # Something changed
@@ -100,6 +103,11 @@ class AnimatedSprite:
             # State changed
 
             self._timer = data["duration"][0]
+            self._ox = data["ox"][0]
+            self._oy = data["oy"][0]
+            self._image_name = data["image"][0]
+            self.width = data["width"][0]
+            self.height = data["height"][0]
 
         self._last_direction = direction
         self._last_graphic_state = graphic_state
@@ -110,30 +118,27 @@ class AnimatedSprite:
         py: float,
         camera_name: str = "display",
         absolute_position: bool = False,
+        draw_to_ui: bool = False,
     ):
-        if self.name == "":
+        if not self.name:
             return
 
-        data = self._get_data(self._last_graphic_state, self._last_direction)
         if not absolute_position:
             px *= self.engine.rtc.tile_width
             py *= self.engine.rtc.tile_height
         px, py = math.floor(px), math.floor(py)
-        try:
-            self.engine.backend.draw_partial_sprite(
-                px,
-                py,
-                self.name,
-                data["ox"][self._frame_index] * self.width,
-                data["oy"][self._frame_index] * self.height,
-                self.width,
-                self.height,
-                camera_name,
-            )
-        except KeyError:
-            LOG.exception(
-                f"Data of {self._tileset_name, self.name} is malformed: {data}"
-            )
+
+        self.engine.backend.draw_partial_sprite(
+            px,
+            py,
+            self._image_name,
+            self._ox * self.width,
+            self._oy * self.height,
+            self.width,
+            self.height,
+            camera_name,
+            draw_to_ui=draw_to_ui,
+        )
 
     def _load_sprites_from_tileset(self, tileset, sprite_name):
         if sprite_name in AnimatedSprite.sprite_sets:
@@ -185,16 +190,15 @@ class AnimatedSprite:
         if graphic_state == GraphicState.DEFEATED:
             graphic_state = graphic_state.DEAD
 
-        data = self._sprites.get(
-            graphic_state, self._sprites.get(GraphicState.STANDING, {})
+        data = self.sprite_sheet.get(
+            graphic_state, self.sprite_sheet.get(GraphicState.STANDING, {})
         )
         data = data.get(direction, data.get(Direction.SOUTH, {}))
         if not data:
             try:
                 LOG.debug(
-                    "Animation of sprite %s,%s is empty for %s, %s ",
-                    self._tileset_name,
-                    self._sprite_name,
+                    "Animation of sprite %s is empty for %s, %s ",
+                    self.name,
                     graphic_state.name,
                     direction.name,
                 )
@@ -202,5 +206,12 @@ class AnimatedSprite:
                 # print(graphic_state, direction)
                 LOG.exception(graphic_state, direction)
                 raise
-            data = {"ox": [0], "oy": [0], "duration": [1.0]}
+            data = {
+                "ox": [0],
+                "oy": [0],
+                "duration": [1.0],
+                "image": [""],
+                "width": [0],
+                "height": [0],
+            }
         return data

mima/objects/creature.py

@@ -33,16 +33,23 @@ class Creature(Dynamic):
         py: float = 0,
         name: str = "Unnamed Creature",
         *,
+        sprite_name: str = "",
         tilemap: Tilemap = None,
         dyn_id: int = -1,
-        tileset_name: str = "",
-        image_name: str = "",
-        sprite_name: str = "",
         player: Player = Player.P0,
     ):
-        super().__init__(px, py, name, tilemap, dyn_id)
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+        )
 
-        self.sprite = AnimatedSprite(tileset_name, image_name, sprite_name)
+        # self.sprite = self.engine.db.get_sprite(
+        #     sprite_name
+        # )  # AnimatedSprite(tileset_name, image_name, sprite_name)
         self.player = player
         self.type = ObjectType.CREATURE
         self.knock_speed: float = DEFAULT_KNOCK_SPEED
@@ -196,8 +203,8 @@ class Creature(Dynamic):
 
         if self.pz != 0:
             self.engine.backend.fill_circle(
-                px + 0.5 * self.sprite.width,
-                py + 0.7 * self.sprite.height,
+                (px + 0.5) * self.sprite.width,
+                (py + 0.7) * self.sprite.height,
                 0.3125 * self.sprite.width,
                 BLACK,
                 camera_name,

mima/objects/dynamic.py

@@ -28,6 +28,8 @@ class Dynamic:
         px: float = 0.0,
         py: float = 0.0,
         name: str = "Unnamed Dynamic",
+        *,
+        sprite_name: str = "",
         tilemap: Optional[Tilemap] = None,
         dyn_id=-1,
     ):
@@ -91,7 +93,7 @@ class Dynamic:
         self.can_lift: bool = False
         self.can_push: bool = False
 
-        self.sprite: Sprite = Sprite()
+        self.sprite: Sprite = self.engine.db.get_sprite(sprite_name)
 
         # Performance
         self.chunks: List[int] = []

mima/objects/effects/colorize_screen.py

@@ -17,7 +17,15 @@ class ColorizeScreen(Projectile):
         to_filter: bool = False,
         cameras: Optional[List[str]] = None,
     ):
-        super().__init__(0, 0, 0, 0, duration, Alignment.GOOD, None)
+        super().__init__(
+            0,
+            0,
+            "ColorizeScreen",
+            vx=0,
+            vy=0,
+            duration=duration,
+            alignment=Alignment.GOOD,
+        )
         self.layer = 1
         self.solid_vs_map = False
         self.color = color

mima/objects/effects/light.py

@@ -15,7 +15,12 @@ class Light(Projectile):
         update_from_target: bool = False,
     ):
         super().__init__(
-            0, 0, 0, 0, 0, Alignment.GOOD, follow.tilemap, "Light"
+            0,
+            0,
+            name="Light",
+            tilemap=follow.tilemap,
+            duration=0,
+            alignment=Alignment.GOOD,
         )
         self.layer = 1
         self.sprite.name = "light_small"

mima/objects/effects/show_sprite.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Optional
 
 from ...types.alignment import Alignment
 from ..projectile import Projectile
@@ -15,17 +15,28 @@ class ShowSprite(Projectile):
         self,
         px: float,
         py: float,
-        sprite: Sprite,
-        tilemap: Tilemap,
-        layer: int = 0,
+        name: str = "ShowSprite",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
         dyn_id: int = 0,
+        layer: int = 0,
     ):
         super().__init__(
-            px, py, 0.0, 0.0, 0.0, Alignment.NEUTRAL, tilemap, "SpriteEffect"
+            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.sprite: Sprite = sprite
+        self.draw_to_ui: bool = False
 
     def update(self, elapsed_time: float):
         self.sprite.update(

mima/objects/effects/walking_on_grass.py

@@ -5,17 +5,30 @@ from ..projectile import Projectile
 
 
 class WalkingOnGrass(Projectile):
-    def __init__(self, follow: Dynamic):
+    def __init__(
+        self,
+        follow: Dynamic,
+        name: str = "WalkingOnGrass",
+        sprite_name: str = "walking_on_grass",
+    ):
         super().__init__(
-            follow.px, follow.py, 0, 0, 1.0, follow.alignment, follow.tilemap
+            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.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
@@ -37,11 +50,12 @@ class WalkingOnGrass(Projectile):
             / self.engine.rtc.tile_height
         )
 
-        if self._follow.graphic_state == GraphicState.STANDING:
-            elapsed_time = 0
-        self.sprite.update(
-            elapsed_time, Direction.SOUTH, GraphicState.STANDING
-        )
+        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
 

mima/objects/effects/walking_on_water.py

@@ -5,41 +5,46 @@ 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
+    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 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 (

mima/objects/loader.py

@@ -13,6 +13,7 @@ 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
@@ -38,6 +39,7 @@ class ObjectLoader:
             "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,
@@ -69,10 +71,9 @@ class ObjectLoader:
                 )
             except (KeyError, ValueError):
                 LOG.exception(
-                    f"Failed to load '{obj.name}' ({obj.object_id}: "
-                    f"{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:
@@ -98,17 +99,13 @@ class ObjectLoader:
                                         f"Logic Gate {listener.dyn_id}"
                                     )
 
-    def load_creature_from_tiled_object(
-        self, obj, px, py, width, height, tilemap
-    ):
+    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})"
-            )
+            LOG.exception(f"Failed to load '{obj.name}' ({obj.object_id}: {obj.type})")
             # raise
             return []

mima/objects/projectile.py

@@ -16,14 +16,24 @@ class Projectile(Dynamic):
         self,
         px: float,
         py: float,
-        vx: float,
-        vy: 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,
-        tilemap: Tilemap = None,
-        name: str = "Projectile",
     ):
-        super().__init__(px, py, name, tilemap)
+        super().__init__(
+            px,
+            py,
+            name,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+        )
 
         self.type = ObjectType.PROJECTILE
         self.vx = vx

mima/objects/sprite.py

@@ -72,7 +72,13 @@ class Sprite:
         self.last_direction = direction
         self.last_graphic_state = graphic_state
 
-    def draw_self(self, px: float, py: float, camera_name: str = "display"):
+    def draw_self(
+        self,
+        px: float,
+        py: float,
+        camera_name: str = "display",
+        draw_to_ui: bool = False,
+    ):
         if self.name == "":
             return
 
@@ -102,6 +108,7 @@ class Sprite:
             self.width,
             self.height,
             camera_name,
+            draw_to_ui=draw_to_ui,
         )
 
     def reset(self):

mima/objects/world/color_gate.py

@@ -1,5 +1,6 @@
 from typing import List, Optional, Union
 
+from ...maps.tilemap import Tilemap
 from ...types.direction import Direction
 from ...types.gate_color import GateColor
 from ...types.graphic_state import GraphicState
@@ -15,28 +16,25 @@ class ColorGate(Gate):
         self,
         px: float,
         py: float,
-        tileset_name: str,
-        image_name: str,
-        sprite_name: str,
-        graphic_state: GraphicState,
-        facing_direction: Direction,
-        color: GateColor,
-        tilemap=None,
-        dyn_id: int = -1,
         name: str = "ColorGate",
+        *,
+        sprite_name: str = "",
+        tilemap: Optional[Tilemap] = None,
+        dyn_id: int = -1,
+        graphic_state: GraphicState = GraphicState.STANDING,
+        facing_direction: Direction = Direction.SOUTH,
+        color: GateColor = GateColor.RED,
     ):
         super().__init__(
             px,
             py,
             name,
-            tileset_name,
-            image_name,
-            sprite_name,
-            graphic_state,
-            facing_direction,
-            False,
-            tilemap,
-            dyn_id,
+            sprite_name=sprite_name,
+            tilemap=tilemap,
+            dyn_id=dyn_id,
+            graphic_state=graphic_state,
+            facing_direction=facing_direction,
+            bombable=False,
         )
         self.color = color
         self.type = ObjectType.COLOR_GATE
@@ -53,9 +51,10 @@ class ColorGate(Gate):
         gate = ColorGate(
             px=px,
             py=py,
-            tileset_name=obj.get_string("tileset_name"),
-            image_name=obj.get_string("tileset_name"),
+            name=obj.name,
             sprite_name=obj.get_string("sprite_name"),
+            tilemap=tilemap,
+            dyn_id=obj.object_id,
             graphic_state=GraphicState[
                 obj.get_string("graphic_state", "closed").upper()
             ],
@@ -63,9 +62,6 @@ 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,
         )
 
         return [gate]