mima-engine 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

mima/maps/tiled/tiled_tileset.py

@@ -33,14 +33,19 @@ class TiledTileset(Tileset):
 
         LOG.debug("Loading image properties ...")
         image = root.findall("image")[0]
-        self.sprite_name: str = os.path.split(image.attrib["source"])[-1][:-4]
+        self.image_name: str = os.path.split(image.attrib["source"])[-1][:-4]
         self.sprite_width: int = int(image.attrib["width"])
         self.sprite_height: int = int(image.attrib["height"])
 
         LOG.debug("Loading tiles ...")
         tiles = root.findall("tile")
-        
+
         for tile in tiles:
-            self.tiles.append(TiledTile(tile))
-            if self.tiles[-1].animated:
-                self.animated_tiles.append(self.tiles[-1])
+            t_obj = TiledTile(tile)
+            self.tiles.append(t_obj)
+            if t_obj.animated:
+                self.animated_tiles.append(t_obj)
+            if t_obj.sprite_name:
+                self.sprite_names.setdefault(t_obj.sprite_name, []).append(
+                    t_obj.tile_id
+                )

mima/maps/tilemap.py

@@ -64,12 +64,8 @@ class Tilemap(Template):
             if layer.layer_pos != layer_pos:
                 continue
 
-            layer_ox = (
-                layer.layer_ox - math.floor(layer.layer_ox)
-            ) * self.tile_width
-            layer_oy = (
-                layer.layer_oy - math.floor(layer.layer_oy)
-            ) * self.tile_height
+            layer_ox = (layer.layer_ox - math.floor(layer.layer_ox)) * self.tile_width
+            layer_oy = (layer.layer_oy - math.floor(layer.layer_oy)) * self.tile_height
 
             layer_visible_tiles_sx = int(visible_tiles_sx)
             layer_visible_tiles_sy = int(visible_tiles_sy)
@@ -81,9 +77,7 @@ class Tilemap(Template):
 
             # Draw visible tiles of the map
             for x in range(layer_visible_tiles_sx, int(visible_tiles_ex) + 2):
-                for y in range(
-                    layer_visible_tiles_sy, int(visible_tiles_ey) + 2
-                ):
+                for y in range(layer_visible_tiles_sy, int(visible_tiles_ey) + 2):
                     tile_index = layer.get_index(
                         int(x + math.floor(ox)), int(y + math.floor(oy))
                     )
@@ -103,7 +97,7 @@ class Tilemap(Template):
                     self.engine.backend.draw_partial_sprite(
                         math.floor(x * self.tile_width - tile_ox + layer_ox),
                         math.floor(y * self.tile_height - tile_oy + layer_oy),
-                        info.tileset.sprite_name,
+                        info.tileset.image_name,
                         sx * self.tile_width,
                         sy * self.tile_height,
                         self.tile_width,

mima/maps/tileset.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import Dict, List
 
 from .tile import Tile
 
@@ -6,10 +6,10 @@ from .tile import Tile
 class Tileset:
     def __init__(self):
         self.name: str = "Unnamed Tileset"
-        self.sprite_name: str = ""
+        self.image_name: str = ""
         # self.filename: str = ""
-        self.sprite_width: int = 0
-        self.sprite_height: int = 0
+        self.image_width: int = 0
+        self.image_height: int = 0
         self.tile_width: int = 0
         self.tile_height: int = 0
         self.tile_count: int = 0
@@ -17,6 +17,7 @@ class Tileset:
 
         self.tiles: List[Tile] = []
         self.animated_tiles: List[Tile] = []
+        self.sprite_names: Dict[str, List[int]] = {}
         self._is_new_frame: bool = False
 
     def update(self, elapsed_time: float) -> bool:

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,
@@ -291,6 +298,12 @@ class Creature(Dynamic):
 
         self.projectiles = []
 
+    def on_enter_map(self):
+        pass
+
+    def on_exit_map(self):
+        pass
+
     def on_death(self):
         if self.spawn_on_death:
             for do in self.spawn_on_death:

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/debug_box.py

@@ -21,7 +21,12 @@ class DynamicDebugBox(Projectile):
         ids=None,
     ) -> None:
         super().__init__(
-            0, 0, 0, 0, 0, Alignment.NEUTRAL, follow.tilemap, "DynamicDebugBox"
+            0,
+            0,
+            "DynamicDebugBox",
+            duration=0.0,
+            alignment=Alignment.NEUTRAL,
+            tilemap=follow.tilemap,
         )
         self.layer = 2
         self.sprite = None
@@ -76,7 +81,11 @@ class DynamicDebugBox(Projectile):
 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"
+            px,
+            py,
+            "StaticDebugBox",
+            duration=0.0,
+            alignment=Alignment.NEUTRAL,
         )
         self.layer = 2
         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 []