mima-engine 0.4.0__py3-none-any.whl

mima/maps/tiled/tiled_objectgroup.py

@@ -0,0 +1,25 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+from .tiled_object import TiledObject
+
+if TYPE_CHECKING:
+    from xml.etree.ElementTree import Element
+
+
+class TiledObjectgroup:
+    def __init__(self, o_xtree: Element):
+        self.name: str = o_xtree.attrib["name"]
+        self.layer_id: int = int(o_xtree.attrib["id"])
+
+        self._objects: List[TiledObject] = []
+
+        objects = o_xtree.findall("object")
+
+        for obj in objects:
+            self._objects.append(TiledObject(obj))
+
+    @property
+    def objects(self):
+        return self._objects

mima/maps/tiled/tiled_template.py

@@ -0,0 +1,49 @@
+import logging
+import os
+from xml.etree import ElementTree
+
+from ...util.property import Property
+from ..template import Template
+
+LOG = logging.getLogger(__name__)
+
+
+class TiledTemplate(Template):
+    def __init__(self, name: str, filename: str):
+        super().__init__(name)
+
+        LOG.info(
+            "Loading template %s from TX file at '%s' ...",
+            name,
+            filename,
+        )
+
+        tree = ElementTree.parse(filename)
+        LOG.debug("Loaded file %s successfully.", filename)
+
+        root = tree.getroot()
+        tileset = root.findall("tileset")[0]
+        LOG.debug("Loading tileset properties ...")
+        self.first_gid = int(tileset.attrib["firstgid"])
+        self.tileset_name = os.path.split(tileset.attrib["source"])[-1].split(
+            "."
+        )[0]
+
+        obj = root.findall("object")[0]
+        self.oname = obj.attrib.get("name", "Unnamed")
+        self.otype = obj.attrib.get("type", obj.attrib.get("class", "Untyped"))
+        self.gid = int(obj.attrib["gid"])
+        self.width = int(obj.attrib["width"])
+        self.height = int(obj.attrib["height"])
+
+        props = obj.findall("properties")
+        if props:
+            props = props[0].findall("property")
+
+            for p in props:
+                pname = p.attrib["name"]
+                self.properties[pname] = Property(
+                    name=pname,
+                    dtype=p.attrib.get("type", "str"),
+                    value=p.attrib["value"],
+                )

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,51 @@
+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.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:
+            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

@@ -0,0 +1,216 @@
+from __future__ import annotations
+
+import logging
+import math
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from ..types.tile_collision import TileCollision
+from .template import Template
+from .tile_info import TileInfo
+from .tile_layer import TileLayer
+from .tileset_info import TilesetInfo
+
+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 = self.engine.rtc.tile_width
+        self.tile_height = self.engine.rtc.tile_height
+
+        self._layers: List[TileLayer] = []
+        self._tilesets: List[TilesetInfo] = []
+        self._cache: Dict[int, TileInfo] = {}
+        self._objects: List[Template] = []
+
+    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,
+        camera_name: str = "display",
+    ):
+        # 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) + 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))
+                    )
+                    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.image_name,
+                        sx * self.tile_width,
+                        sy * self.tile_height,
+                        self.tile_width,
+                        self.tile_height,
+                        camera_name,
+                    )
+        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,
+        collision: TileCollision = TileCollision.TOP,
+    ) -> bool:
+        if collision in (TileCollision.TOP, TileCollision.BOTTOM):
+            tile = self.get_tile(
+                px,
+                py,
+                layer_pos,
+                ascending=(collision == TileCollision.BOTTOM),
+            )
+
+            if tile is not None and tile.solid:
+                return True
+            return False
+
+        tiles = self.get_tiles(px, py, layer_pos)
+        if collision in (TileCollision.TOP_2, TileCollision.TOP_3):
+            tiles = tiles[::-1]
+
+        for idx, tile in enumerate(self.get_tiles(px, py, layer_pos)):
+            if tile.solid:
+                return True
+            if idx == 1 and collision in (
+                TileCollision.TOP_2,
+                TileCollision.BOTTOM_2,
+            ):
+                break
+            elif idx == 2 and collision in (
+                TileCollision.TOP_3,
+                TileCollision.BOTTOM_3,
+            ):
+                break
+        return False
+
+    def get_tile(
+        self,
+        px: int,
+        py: int,
+        layer_pos: Optional[int] = None,
+        ascending=False,
+    ) -> Optional[Tile]:
+        if ascending:
+            layers = self._layers
+        else:
+            layers = self._layers[::-1]
+
+        for layer in layers:
+            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 get_tiles(self, px: int, py: int, layer_pos: Optional[int] = None):
+        tiles = []
+        for layer in self._layers:
+            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:
+                tiles.append(info.tile)
+
+        return tiles
+
+    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
+
+    def trigger_new_frame(self):
+        for tsinfo in self._tilesets:
+            tsinfo.tileset.trigger_new_frame()
+
+    @property
+    def objects(self) -> List[Template]:
+        return []

mima/maps/tileset.py

@@ -0,0 +1,39 @@
+from typing import Dict, List
+
+from .tile import Tile
+
+
+class Tileset:
+    def __init__(self):
+        self.name: str = "Unnamed Tileset"
+        self.image_name: str = ""
+        # self.filename: str = ""
+        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
+        self.columns: int = 0
+
+        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:
+        if self._is_new_frame:
+            for tile in self.animated_tiles:
+                tile.update(elapsed_time)
+            self._is_new_frame = False
+
+        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]
+
+    def trigger_new_frame(self):
+        self._is_new_frame = True

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,146 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ..util.constants import (
+    MAP_TRANSITION_DURATION_FACTOR,
+    MOVE_MAP_DURATION,
+    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 / self.engine.rtc.tile_width
+        )
+        self.tiles_ny = (
+            self.engine.backend.render_height / self.engine.rtc.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)
+
+    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