mima-engine 0.1.0__py3-none-any.whl

mima/maps/tiled/tiled_tile.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+from ...types.direction import Direction
+from ...types.graphic_state import GraphicState
+from ...types.terrain import Terrain
+from ...util.functions import strtobool
+from ..tile import Tile
+from ..tile_animation import TileAnimation
+
+if TYPE_CHECKING:
+    from xml.etree.ElementTree import Element
+
+
+class TiledTile(Tile):
+    def __init__(self, t_xtree: Element):
+        super().__init__()
+
+        self.tile_type: str = t_xtree.attrib.get(
+            "class", t_xtree.attrib.get("type", "tile")
+        )
+
+        self.basic_tile_id: int = int(t_xtree.attrib["id"])
+        self.tile_id: int = self.basic_tile_id
+
+        self._frames: List[TileAnimation] = []
+        self._frame: int = 0
+        self._num_frames: int = 0
+        self._frame_timer: float = 0.0
+
+        animation = t_xtree.findall("animation")
+
+        if animation:
+            frames = animation[0].findall("frame")
+            for frame in frames:
+                self._frames.append(
+                    TileAnimation(
+                        frame_id=int(frame.attrib["tileid"]),
+                        duration=int(frame.attrib["duration"]) / 1000.0,
+                    )
+                )
+            self.animated = True
+        else:
+            self._frames.append(
+                TileAnimation(frame_id=self.basic_tile_id, duration=0.0)
+            )
+
+        self._num_frames = len(self._frames)
+
+        self.tile_id = self._frames[0].frame_id
+        self._frame_timer = self._frames[0].duration
+
+        properties = t_xtree.findall("properties")
+        if properties:
+            properties = properties[0].findall("property")
+            for prop in properties:
+                if prop.attrib["name"] == "solid":
+                    self.solid = strtobool(prop.attrib["value"])
+                if prop.attrib["name"] == "ground_type":
+                    try:
+                        self.terrain = Terrain[prop.attrib["value"].upper()]
+                    except:
+                        self.terrain = Terrain.DEFAULT
+                if prop.attrib["name"] == "z_height":
+                    self.z_height = float(prop.attrib["value"])
+                if prop.attrib["name"] == "facing_direction":
+                    self.facing_direction = Direction[
+                        prop.attrib.get("value", "south").upper()
+                    ]
+                if prop.attrib["name"] == "graphic_state":
+                    self.graphic_state = GraphicState[
+                        prop.attrib.get("value", "standing").upper()
+                    ]
+                if prop.attrib["name"] == "sprite_name":
+                    self.sprite_name = prop.attrib.get("value", "")
+
+    def update(self, elapsed_time: float) -> bool:
+        if self._num_frames <= 1:
+            return False
+
+        self._frame_timer -= elapsed_time
+        if self._frame_timer <= 0:
+            self._frame = (self._frame + 1) % self._num_frames
+            self.tile_id = self._frames[self._frame].frame_id
+            self._frame_timer += self._frames[self._frame].duration
+
+            return True
+
+        return False

mima/maps/tiled/tiled_tileset.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import logging
+import os
+from xml.etree import ElementTree
+
+from ..tileset import Tileset
+from .tiled_tile import TiledTile
+
+LOG = logging.getLogger(__name__)
+
+
+class TiledTileset(Tileset):
+    def __init__(self, name: str, filename: str):
+        super().__init__()
+
+        self.name = name
+
+        LOG.info(
+            "Loading tileset %s from TSX file at '%s' ...",
+            name,
+            filename,
+        )
+        tree = ElementTree.parse(filename)
+        LOG.debug("Loaded file %s successfully.", filename)
+
+        root = tree.getroot()
+        LOG.debug("Loading tileset properties ...")
+        self.tile_width: int = int(root.attrib["tilewidth"])
+        self.tile_height: int = int(root.attrib["tileheight"])
+        self.tile_count: int = int(root.attrib["tilecount"])
+        self.columns: int = int(root.attrib["columns"])
+
+        LOG.debug("Loading image properties ...")
+        image = root.findall("image")[0]
+        self.sprite_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])

mima/maps/tilemap.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import logging
+import math
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from ..util.constants import TILE_HEIGHT, TILE_WIDTH
+from .tile_info import TileInfo
+from .tile_layer import TileLayer
+from .tileset_info import TilesetInfo
+from .template import Template
+
+if TYPE_CHECKING:
+    from ..objects.dynamic import Dynamic
+    from ..types.nature import Nature
+    from .tile import Tile
+
+
+LOG = logging.getLogger(__name__)
+
+
+class Tilemap(Template):
+
+    def __init__(self, name: str):
+        super().__init__(name)
+        self.width: int = 0
+        self.height: int = 0
+        self.tile_width = TILE_WIDTH
+        self.tile_height = TILE_HEIGHT
+
+        self._layers: List[TileLayer] = []
+        self._tilesets: List[TilesetInfo] = []
+        self._cache: Dict[int, TileInfo] = {}
+
+    def populate_dynamics(self, dynamics: List[Dynamic]) -> bool:
+        """Load all map-related objects into the game."""
+        return False
+
+    def update(self, elapsed_time: float) -> bool:
+        for info in self._tilesets:
+            info.tileset.update(elapsed_time)
+
+        for layer in self._layers:
+            layer.update(elapsed_time)
+
+        return True
+
+    def draw_self(
+        self,
+        ox: float,
+        oy: float,
+        visible_tiles_sx: int,
+        visible_tiles_sy: int,
+        visible_tiles_ex: int,
+        visible_tiles_ey: int,
+        layer_pos: int = 0,
+    ):
+        # Get offsets for smooth movement
+        tile_ox = (ox - math.floor(ox)) * self.tile_width
+        tile_oy = (oy - math.floor(oy)) * self.tile_height
+
+        for layer in self._layers:
+            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_visible_tiles_sx = int(visible_tiles_sx)
+            layer_visible_tiles_sy = int(visible_tiles_sy)
+
+            if layer.speed_x != 0.0:
+                layer_visible_tiles_sx -= 1
+            if layer.speed_y != 0.0:
+                layer_visible_tiles_sy -= 1
+
+            # Draw visible tiles of the map
+            for x in range(layer_visible_tiles_sx, int(visible_tiles_ex) + 1):
+                for y in range(
+                    layer_visible_tiles_sy, int(visible_tiles_ey) + 1
+                ):
+                    tile_index = layer.get_index(
+                        int(x + math.floor(ox)),
+                        int(y + math.floor(oy)),
+                    )
+                    if tile_index <= 0:
+                        # Zero means the tile was not set in Tiled
+                        continue
+
+                    if tile_index not in self._cache:
+                        if not self._load_to_cache(tile_index):
+                            continue
+
+                    info = self._cache[tile_index]
+
+                    sx = info.tile.tile_id % info.tileset.columns
+                    sy = info.tile.tile_id // info.tileset.columns
+
+                    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,
+                        sx * self.tile_width,
+                        sy * self.tile_height,
+                        self.tile_width,
+                        self.tile_height,
+                    )
+        return True
+
+    def on_interaction(self, target: Dynamic, nature: Nature) -> bool:
+        return False
+
+    def is_solid(
+        self, px: int, py: int, layer_pos: Optional[int] = None
+    ) -> bool:
+        tile = self.get_tile(px, py, layer_pos)
+        if tile is not None and tile.solid:
+            return True
+        return False
+
+    def get_tile(
+        self, px: int, py: int, layer_pos: Optional[int] = None
+    ) -> Optional[Tile]:
+        for layer in self._layers[::-1]:
+            if layer_pos is not None and layer_pos != layer.layer_pos:
+                continue
+            tile_index = layer.get_index(math.floor(px), math.floor(py))
+            if tile_index not in self._cache:
+                if not self._load_to_cache(tile_index):
+                    continue
+
+            info = self._cache[tile_index]
+            if info.tile is not None:
+                return info.tile
+
+        return None
+
+    def _load_to_cache(self, tile_index: int) -> bool:
+        tileset = None
+        firstgid = 0
+        for tsinfo in self._tilesets:
+            if tile_index < tsinfo.first_gid:
+                break
+
+            firstgid = tsinfo.first_gid
+            tileset = tsinfo.tileset
+
+        if tileset is None:
+            return False
+
+        tidx = tile_index - firstgid
+        tile = tileset.get_tile(tidx)
+
+        self._cache[tile_index] = TileInfo(tileset=tileset, tile=tile)
+        return True

mima/maps/tileset.py

@@ -0,0 +1,32 @@
+from typing import List
+
+from .tile import Tile
+
+
+class Tileset:
+    def __init__(self):
+        self.name: str = "Unnamed Tileset"
+        self.sprite_name: str = ""
+        # self.filename: str = ""
+        self.sprite_width: int = 0
+        self.sprite_height: int = 0
+        self.tile_width: int = 0
+        self.tile_height: int = 0
+        self.tile_count: int = 0
+        self.columns: int = 0
+
+        self.tiles: List[Tile] = []
+        self.animated_tiles: List[Tile] = []
+
+    def update(self, elapsed_time: float) -> bool:
+        for tile in self.animated_tiles:
+            tile.update(elapsed_time)
+
+        return True
+
+    def get_tile(self, tile_id: int) -> Tile:
+        for tile in self.tiles:
+            if tile.basic_tile_id == tile_id:
+                return tile
+
+        return self.tiles[0]

mima/maps/tileset_info.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+from .tileset import Tileset
+
+
+@dataclass
+class TilesetInfo:
+    tileset: Tileset
+    first_gid: int

mima/maps/transition_map.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ..util.constants import (
+    MAP_TRANSITION_DURATION_FACTOR,
+    MOVE_MAP_DURATION,
+    TILE_HEIGHT,
+    TILE_WIDTH,
+    UI_HIGHT,
+)
+from .tilemap import Tilemap
+
+if TYPE_CHECKING:
+    from .tile import Tile
+
+
+class TransitionMap(Tilemap):
+    def __init__(
+        self, src_map: Tilemap, dst_map: Tilemap, dst_vx: int, dst_vy: int
+    ):
+        super().__init__(src_map.name)
+
+        self.src_map: Tilemap = src_map
+        self.dst_map: Tilemap = dst_map
+        self.vx: int = int(dst_vx)
+        self.vy: int = int(dst_vy)
+        self.progress: float = 0.0
+        self.duration: float = (
+            MOVE_MAP_DURATION * MAP_TRANSITION_DURATION_FACTOR
+        )
+        self.time_so_far: float = 0.0
+        self.step_size: float = 1.0
+        self._extra_oy = UI_HIGHT
+
+        self.width: int = self.src_map.width
+        self.height: int = self.src_map.height
+        self.tiles_nx = self.engine.backend.render_width / TILE_WIDTH
+        self.tiles_ny = self.engine.backend.render_height / TILE_HEIGHT
+
+        if self.vx != 0:
+            self.step_size = self.duration / (self.tiles_nx * 0.75)
+        elif self.vy != 0:
+            self.step_size = self.duration / ((self.tiles_ny - 1) * 0.75)
+
+        # print(
+        #     f"Step Size={self.step_size}, Duration={self.duration}, Size={WIDTH, HEIGHT}, TileSize={TILE_WIDTH, TILE_HEIGHT} "
+        # )
+
+    def update(self, elapsed_time: float) -> bool:
+        self.progress = self.time_so_far / self.step_size
+        self.time_so_far += elapsed_time
+
+        return self.src_map.update(elapsed_time)
+
+    def draw_self(
+        self,
+        ox: float,
+        oy: float,
+        visible_tiles_sx: int,
+        visible_tiles_sy: int,
+        visible_tiles_ex: int,
+        visible_tiles_ey: int,
+        layer_pos: int = 0,
+    ) -> bool:
+        src_tiles_sx = dst_tiles_sx = int(visible_tiles_sx)
+        src_tiles_sy = dst_tiles_sy = int(visible_tiles_sy)
+        src_tiles_ex = dst_tiles_ex = int(visible_tiles_ex)
+        src_tiles_ey = dst_tiles_ey = int(visible_tiles_ey)
+        src_ox = dst_ox = ox
+        src_oy = dst_oy = oy
+
+        if self.vx < 0:  # Transition west
+            src_tiles_sx += int(self.progress)
+            src_tiles_ex += int(self.progress)
+            dst_tiles_ex = src_tiles_sx + 1
+            src_ox = max(-self.tiles_nx, -self.progress)
+            dst_ox = (
+                self.dst_map.width - self.tiles_nx + visible_tiles_ex + src_ox
+            )
+
+        elif self.vx > 0:  # Transition east
+            src_tiles_sx -= int(self.progress)
+            src_tiles_ex -= int(self.progress)
+            dst_tiles_sx = src_tiles_ex
+            src_ox = self.src_map.width + min(0, self.progress - self.tiles_nx)
+            dst_ox = src_ox - self.src_map.width
+
+        elif self.vy < 0:  # Transition north
+            src_tiles_sy += int(self.progress)
+            src_tiles_ey += int(self.progress)
+            dst_tiles_ey = src_tiles_sy + 1
+            src_oy = max(-self.tiles_ny, -self.progress - self._extra_oy)
+            dst_oy = (
+                self.dst_map.height - self.tiles_ny + visible_tiles_ey + src_oy
+            )
+
+        elif self.vy > 0:  # Transition south
+            src_tiles_sy -= int(self.progress)
+            src_tiles_ey -= int(self.progress)
+            dst_tiles_sy = src_tiles_ey
+            src_oy = self.src_map.height + min(
+                0, self.progress - self.tiles_ny
+            )
+            dst_oy = -visible_tiles_ey + self.progress
+
+        # if layer_pos == 0:
+        #     print(
+        #         f"o({ox:.2f}),t({self.tiles_nx}),"
+        #         f"ss({self.src_map.width}),so({src_ox:.2f}),"
+        #         f"ts({src_tiles_sx}),te({src_tiles_ex}) -> "
+        #         f"ds({self.dst_map.width}),do({dst_ox:.2f}),"
+        #         f"ts({dst_tiles_sx}),te({dst_tiles_ex})"
+        #     )
+        # print(
+        #     f"o({ox:.2f},{oy:.2f}),"
+        #     f"ss({self.src_map.width},{self.src_map.height}),so({src_ox:.2f},{src_oy:.2f}),"
+        #     f"ts({src_tiles_sx},{src_tiles_sy}),te{src_tiles_ex,src_tiles_ey} -> "
+        #     f"ds({self.dst_map.width},{self.dst_map.height}),do({dst_ox:.2f},{dst_oy:.2f}),"
+        #     f"ts({dst_tiles_sx},{dst_tiles_sy}),te({dst_tiles_ex},{dst_tiles_ey})"
+        # )
+        # print(src_oy, dst_oy, self.map_screen_oy)
+        self.src_map.draw_self(
+            src_ox,
+            src_oy,
+            src_tiles_sx,
+            src_tiles_sy,
+            src_tiles_ex,
+            src_tiles_ey,
+            layer_pos,
+        )
+        self.dst_map.draw_self(
+            dst_ox,
+            dst_oy,
+            dst_tiles_sx,
+            dst_tiles_sy,
+            dst_tiles_ex,
+            dst_tiles_ey,
+            layer_pos,
+        )
+
+        return True
+
+    def is_solid(self, px: int, py: int) -> bool:
+        return False
+
+    def get_tile(self, px: int, py: int) -> Optional[Tile]:
+        return None

mima/objects/animated_sprite.py

@@ -0,0 +1,198 @@
+import logging
+import math
+from typing import Any, Dict, Optional
+
+from ..types.direction import Direction
+from ..types.graphic_state import GraphicState
+from ..util.constants import TILE_HEIGHT, TILE_WIDTH
+
+LOG = logging.getLogger(__name__)
+
+
+class AnimatedSprite:
+    engine = None
+    sprite_sets = {}
+
+    def __init__(
+        self,
+        tileset_name: str,
+        image_name: str,
+        sprite_name: Optional[str] = None,
+        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._last_direction: Direction = facing_direction
+            self._last_graphic_state: GraphicState = graphic_state
+            data = self._get_data(
+                self._last_graphic_state, self._last_direction
+            )
+
+            self._frame_index: int = 0
+            self._timer: float = data["duration"][0]
+        else:
+            LOG.debug(
+                f"Sprite information uncomplete. Tileset={tileset_name}, Image"
+                f"={image_name}, Sprite={self._sprite_name}. Will continue without "
+                "sprite."
+            )
+            self.name = self._tileset_name = self._sprite_name = ""
+
+    def update(
+        self,
+        elapsed_time: float,
+        direction: Direction = Direction.SOUTH,
+        graphic_state: GraphicState = GraphicState.STANDING,
+    ):
+        if not self.name:
+            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
+            and graphic_state == self._last_graphic_state
+        ):
+            # No changes, normal case
+            self._timer -= elapsed_time
+            if self._timer <= 0.0:
+                self._frame_index = (self._frame_index + 1) % len(
+                    data["duration"]
+                )
+                self._timer += data["duration"][self._frame_index]
+
+        else:
+            self._frame_index = 0
+            # Something changed
+            # if graphic_state != self._last_graphic_state:
+            # State changed
+
+            self._timer = data["duration"][0]
+
+        self._last_direction = direction
+        self._last_graphic_state = graphic_state
+
+    def draw_self(self, px: float, py: float, absolute_position: bool = False):
+        if self.name == "":
+            return
+
+        data = self._get_data(self._last_graphic_state, self._last_direction)
+        if not absolute_position:
+            px *= TILE_WIDTH
+            py *= 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,
+            )
+        except KeyError as err:
+            LOG.exception(
+                f"Data of {self._tileset_name, self.name} is malformed: {data}"
+            )
+
+    def _load_sprites_from_tileset(self, tileset, sprite_name):
+        if sprite_name in AnimatedSprite.sprite_sets:
+            # Caching
+            return AnimatedSprite.sprite_sets[sprite_name]
+
+        sprites = {}
+
+        for tile in tileset.tiles:
+            if tile.sprite_name != sprite_name:
+                continue
+
+            if tile.animated:
+                data = {"duration": [], "ox": [], "oy": []}
+                for frame in tile._frames:
+                    data["duration"].append(frame.duration)
+                    data["ox"].append(frame.frame_id % tileset.columns)
+                    data["oy"].append(frame.frame_id // tileset.columns)
+            else:
+                data = {
+                    "duration": [1000],
+                    "ox": [tile.tile_id % tileset.columns],
+                    "oy": [tile.tile_id // tileset.columns],
+                }
+
+            sprites.setdefault(tile.graphic_state, {})
+            sprites[tile.graphic_state][tile.facing_direction] = data
+            LOG.debug(
+                {
+                    "operation": "add frames",
+                    "image": self.name,
+                    "sprite": sprite_name,
+                    "graphic_state": tile.graphic_state.name,
+                    "direction": tile.facing_direction.name,
+                    "frame_data": data,
+                }
+            )
+
+        AnimatedSprite.sprite_sets[sprite_name] = sprites
+        return sprites
+        # for tile in tileset.tiles
+        # Check non-animated tiles if necessary
+
+    def reset(self):
+        self._frame_index = 0
+        self._timer = 0.0
+
+    def _get_data(self, graphic_state, direction):
+        if graphic_state == GraphicState.DEFEATED:
+            graphic_state = graphic_state.DEAD
+
+        data = self._sprites.get(
+            graphic_state, self._sprites.get(GraphicState.STANDING, {})
+        )
+        data = data.get(
+            direction,
+            data.get(Direction.SOUTH, {}),
+        )
+        if not data:
+            try:
+                LOG.debug(
+                    f"Animation of sprite {self._tileset_name,self._sprite_name}"
+                    f" is empty for {graphic_state.name, direction.name} "
+                )
+            except Exception:
+                # print(graphic_state, direction)
+                LOG.exception(graphic_state, direction)
+                raise
+            data = {"ox": [0], "oy": [0], "duration": [1.0]}
+        return data