mima-engine 0.1.0__py3-none-any.whl

mima/engine.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import Dict
+
+from .backend.pygame_assets import PygameAssets
+from .backend.pygame_audio import PygameAudio
+from .backend.pygame_backend import PygameBackend
+from .backend.pygame_events import PygameUserInput
+from .maps.template import Template
+from .maps.tilemap import Tilemap
+from .objects.animated_sprite import AnimatedSprite
+from .objects.creature import Creature
+from .objects.dynamic import Dynamic
+from .objects.sprite import Sprite
+from .scripts import Command, ScriptProcessor
+from .states.quest import Quest
+from .types.mode import Mode
+from .types.gate_color import GateColor
+from .usables.item import Item
+from .util import RuntimeConfig
+from .util.logging import install_trace_logger
+from .view.camera import Camera
+from .view.scene import Scene
+
+LOG = logging.getLogger(__name__)
+
+
+class MimaEngine(ABC):
+    def __init__(
+        self, init_file: str, platform: str = "PC", caption: str = "MimaEngine"
+    ):
+        self.rtc = RuntimeConfig()
+        install_trace_logger()
+
+        self.backend: PygameBackend = PygameBackend(
+            self.rtc, init_file, platform
+        )
+
+        self._caption: str = caption
+        self.seconds_total: float = 0.0
+        self.app_fps: float = 0.0
+        self.game_fps: float = 0.0
+        self.elapsed_time: float = 0.00022
+        self._app_time: float = 0.0
+
+        self.mode: Mode = Mode.LOADING
+        self.gate_color: GateColor = GateColor.RED
+        self.n_gate_colors = 2
+        self.script: ScriptProcessor = None
+        self.player: Creature
+        self.quests: List[Quest] = []
+        self._items: Dict[str, Item] = {}
+
+    def construct(
+        self,
+        width: int,
+        height: int,
+        pixel_size: int,
+        fullscreen: bool = False,
+        target_fps: int = 60,
+        resizable: bool = False,
+    ):
+        """Initialize backend and create a window."""
+        AnimatedSprite.engine = self
+        Camera.engine = self
+        Command.engine = self
+        Dynamic.engine = self
+        PygameBackend.engine = self
+        Quest.engine = self
+        Scene.engine = self
+        ScriptProcessor.engine = self
+        Sprite.engine = self
+        Template.engine = self
+        Tilemap.engine = self
+        Item.engine = self
+
+        self.script = ScriptProcessor()
+        self.backend.init()
+        self.backend.construct(
+            width, height, pixel_size, fullscreen, target_fps, resizable
+        )
+        return True
+
+    def start(self):
+        """Start the main loop"""
+        app_frames = 0
+        game_frames = 0
+        app_seconds = 0.0
+        game_seconds = 0.0
+        app_frames_total = 0
+        game_frames_total = 0
+        self.seconds_total = 0.0
+
+        if self.on_user_create():
+            while self.backend.keep_running():
+                self.backend.set_caption(
+                    f"{self._caption} ({self.game_fps:.2f}/{self.app_fps:.2f} fps)"
+                )
+                self.backend.process_events()
+
+                if not self.backend.keep_running():
+                    break
+
+                if not self.on_user_update(self.elapsed_time):
+                    print("Error in on_user_update")
+                    break
+
+                self.backend.update_display()
+
+                self._app_time = self.backend.tick()
+                self.elapsed_time = min(self._app_time, 1.0 / 30.0)
+
+                app_seconds += self._app_time
+                game_seconds += self.elapsed_time
+                app_frames += 1
+                game_frames += 1
+
+                if game_seconds >= 1.0:
+                    game_frames_total += game_frames
+                    self.game_fps = game_frames
+                    game_frames = 0
+                    game_seconds -= 1.0
+                if app_seconds >= 1.0:
+                    app_frames_total += app_frames
+                    self.seconds_total += app_seconds
+                    self.app_fps = app_frames
+                    app_frames = 0
+                    app_seconds -= 1.0
+
+            print(
+                f"App/Game Frames total: {app_frames_total}/{game_frames_total}"
+            )
+            print(f"Seconds total: {self.seconds_total:.3f}")
+            print(
+                f"Average App/Game FPS: {app_frames_total/self.seconds_total:.3f}/"
+                f"{game_frames_total/self.seconds_total:.3f}"
+            )
+
+        self.backend.shutdown()
+
+    @abstractmethod
+    def on_user_update(self, elapsed_time: float) -> bool:
+        """Update."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def on_user_create(self) -> bool:
+        raise NotImplementedError()
+
+    def on_user_terminate(self) -> bool:
+        self.backend.terminate = True
+        return True
+
+    @property
+    def assets(self) -> PygameAssets:
+        return self.backend.assets
+
+    @property
+    def audio(self) -> PygameAudio:
+        return self.backend.audio
+
+    @property
+    def keys(self) -> PygameUserInput:
+        return self.backend.user_input
+
+    def get_map(self, map_name: str):
+        return self.backend.assets.get_map(map_name)
+
+    def load_item(self, item: Item):
+        LOG.debug(f"Loading item  {item.name}.")
+        self._items[item.name] = item
+
+    def get_item(self, item_id: str):
+        try:
+            return self._items[item_id]
+        except KeyError:
+            LOG.error(f"Item '{item_id}' is not defined!")
+            raise
+
+    def progress_quest(self, quest_name: str, new_state: int):
+        for quest in self.quests:
+            if quest.name == quest_name:
+                quest.state = new_state
+
+    def on_enter_background(self):
+        LOG.debug("About to enter background")
+
+    def on_entered_background(self):
+        LOG.debug("Entered background")
+
+    def on_enter_foreground(self):
+        LOG.debug("About to enter foreground")
+
+    def on_entered_foreground(self):
+        LOG.debug("Entered foreground")

mima/maps/template.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, Optional
+
+from ..util.functions import strtobool
+from ..util.property import Property
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+
+
+class Template:
+    engine: MimaEngine
+
+    def __init__(self, name: str):
+        self.name: str = name
+        self.properties: Dict[str, Property] = {}
+
+    def get_string(self, key: str, default_val: str = "") -> str:
+        if key in self.properties:
+            return self.properties[key].value
+        else:
+            return default_val
+
+    def get_int(self, key: str, default_val: int = 0) -> int:
+        if key in self.properties:
+            return int(self.properties[key].value)
+        else:
+            return default_val
+
+    def get_float(self, key: str, default_val: float = 0.0) -> float:
+        if key in self.properties:
+            return float(self.properties[key].value)
+        else:
+            return default_val
+
+    def get_bool(self, key: str, default_val: bool = False) -> bool:
+        if key in self.properties:
+            return bool(strtobool(self.properties[key].value))
+        else:
+            return default_val

mima/maps/tile.py

@@ -0,0 +1,20 @@
+from ..types.direction import Direction
+from ..types.graphic_state import GraphicState
+from ..types.terrain import Terrain
+
+
+class Tile:
+    def __init__(self):
+        self.basic_tile_id: int = 0
+        self.tile_id: int = 0
+        self.solid: bool = False
+        self.animated: bool = False
+        self.pz: float = 0.0
+        self.z_height: float = 0.0
+        self.terrain: Terrain = Terrain.DEFAULT
+        self.facing_direction: Direction = Direction.SOUTH
+        self.graphic_state: GraphicState = GraphicState.STANDING
+        self.sprite_name: str = ""
+
+    def update(self, elapsed_time: float) -> bool:
+        return True

mima/maps/tile_animation.py

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class TileAnimation:
+    frame_id: int
+    duration: float

mima/maps/tile_info.py

@@ -0,0 +1,10 @@
+from dataclasses import dataclass
+
+from .tile import Tile
+from .tileset import Tileset
+
+
+@dataclass
+class TileInfo:
+    tileset: Tileset
+    tile: Tile

mima/maps/tile_layer.py

@@ -0,0 +1,52 @@
+import math
+from typing import List
+
+
+class TileLayer:
+    def __init__(self):
+        self.name: str = "Unnamed Layer"
+        self.layer_id: int = 0
+        self.width: int = 0
+        self.height: int = 0
+        self.layer_pos: int = 0
+        self.speed_x: float = 0.0
+        self.speed_y: float = 0.0
+        self.layer_ox: float = 0.0
+        self.layer_oy: float = 0.0
+        self.parallax_x: float = 0.0  # Not used yet
+        self.parallax_y: float = 0.0  # Not used yet
+
+        self.indices: List[int] = []
+
+    def update(self, elapsed_time: float):
+        self.layer_ox += self.speed_x * elapsed_time
+        self.layer_oy += self.speed_y * elapsed_time
+
+        if self.layer_ox > self.width:
+            self.layer_ox -= self.width
+        if self.layer_ox < 0:
+            self.layer_ox += self.width
+        if self.layer_oy > self.height:
+            self.layer_oy -= self.height
+        if self.layer_oy < 0:
+            self.layer_oy += self.height
+
+    def get_index(self, px: float, py: float) -> int:
+        if self.layer_ox != 0.0:
+            px = math.floor(px - self.layer_ox)
+            if px > self.width:
+                px -= self.width
+            while px < 0:
+                px += self.width
+
+        if self.layer_oy != 0.0:
+            py = math.floor(py - self.layer_oy)
+            if py > self.height:
+                py -= self.height
+            while py < 0:
+                py += self.height
+
+        if 0 <= px < self.width and 0 <= py < self.height:
+            return self.indices[py * self.width + px]
+        else:
+            return 0

mima/maps/tiled/tiled_layer.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import csv
+from io import StringIO
+from typing import TYPE_CHECKING, List
+
+from ..tile_layer import TileLayer
+
+if TYPE_CHECKING:
+    from xml.etree.ElementTree import Element
+
+
+class TiledLayer(TileLayer):
+    def __init__(self, l_xtree: Element):
+        super().__init__()
+
+        self.name: str = l_xtree.attrib["name"]
+        self.layer_id: int = int(l_xtree.attrib["id"])
+        self.type: str = l_xtree.attrib.get("class", "NormalLayer")
+        if "Foreground" in self.type:
+            # FIXME: Hack, propertytypes.json should be read and applied
+            self.layer_pos = 1
+        self.width: int = int(l_xtree.attrib["width"])
+        self.height: int = int(l_xtree.attrib["height"])
+        self.indices: List[int] = []
+
+        layer_data = l_xtree.findall("data")[0]
+        reader = csv.reader(StringIO(layer_data.text), delimiter=",")
+
+        for row in reader:
+            if len(row) <= 0:
+                continue
+
+            for entry in row:
+                try:
+                    self.indices.append(int(entry))
+                except ValueError:
+                    pass  # Empty string
+
+        property_data = l_xtree.findall("properties")
+        for pdata in property_data:
+            properties = pdata.findall("property")
+
+            for prop in properties:
+                if prop.attrib["name"] == "layer":
+                    self.layer_pos = int(prop.attrib["value"])
+                if prop.attrib["name"] == "speed":
+                    self.speed_x = float(prop.attrib.get("value", 0.0))

mima/maps/tiled/tiled_map.py

@@ -0,0 +1,95 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import List
+from xml.etree import ElementTree
+
+from ..tilemap import Tilemap
+from ..tileset_info import TilesetInfo
+from .tiled_layer import TiledLayer
+from .tiled_objectgroup import TiledObjectgroup
+from ...util.property import Property
+
+# if TYPE_CHECKING:
+#     from ..engine import Avare
+
+
+LOG = logging.getLogger(__name__)
+
+
+class TiledMap(Tilemap):
+    def __init__(self, name: str, filename: str = ""):
+        super().__init__(name)
+
+        if filename == "":
+            filename = f"{name}.tmx"
+
+        if not os.path.isfile(filename):
+            filename = os.path.join(
+                self.engine.backend.data_path,
+                "maps",
+                os.path.split(filename)[-1],
+            )
+
+        self._objects: List[TiledObjectgroup] = []
+
+        if not os.path.isfile(filename):
+            filename = os.path.join(
+                self.engine.backend.data_path, "maps", filename
+            )
+
+        LOG.info("Loading map %s from TMX file '%s' ...", name, filename)
+        tree = ElementTree.parse(filename)
+        LOG.debug("Loaded file %s successfully.", filename)
+        root = tree.getroot()
+
+        LOG.debug("Loading map properties ...")
+        self.width = int(root.attrib["width"])
+        self.height = int(root.attrib["height"])
+        self.tile_width = int(root.attrib["tilewidth"])
+        self.tile_height = int(root.attrib["tileheight"])
+
+        LOG.debug("Loading properties ...")
+        properties = root.findall("properties")
+        if properties:
+            properties = properties[0].findall("property")
+            for p in properties:
+                pname = p.attrib["name"]
+                self.properties[pname] = Property(
+                    name=pname,
+                    dtype=p.attrib.get("type", "str"),
+                    value=p.attrib["value"]
+                )
+
+        LOG.debug("Loading tilesets ...")
+        tilesets = root.findall("tileset")  # Only one tileset
+        for tileset in tilesets:
+            tname = os.path.split(tileset.attrib["source"])[-1][:-4]
+            first_gid = int(tileset.attrib["firstgid"])
+            self._tilesets.append(
+                TilesetInfo(
+                    tileset=self.engine.assets.get_tileset(tname),
+                    first_gid=first_gid,
+                )
+            )
+
+        LOG.debug("Loading layers ...")
+        layers = root.findall("layer")
+        for layer in layers:
+            self._layers.append(TiledLayer(layer))
+
+        LOG.debug("Loading objects ...")
+        objectgroups = root.findall("objectgroup")
+        for objectgroup in objectgroups:
+            self._objects.append(TiledObjectgroup(objectgroup))
+
+        LOG.info("Map %s successfully loaded.", self.name)
+
+    @property
+    def objects(self):
+        all_objects = []
+        for group in self._objects:
+            all_objects += group.objects
+
+        return all_objects

mima/maps/tiled/tiled_object.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import os
+from typing import TYPE_CHECKING
+
+from ...util.property import Property
+from ..template import Template
+
+if TYPE_CHECKING:
+    from xml.etree.ElementTree import Element
+
+    from .tiled_template import TiledTemplate
+    from .tiled_tileset import TiledTileset
+
+
+class TiledObject(Template):
+    def __init__(self, o_xtree: Element):
+        super().__init__("TiledObject")
+        self.object_id: int = int(o_xtree.attrib["id"])
+
+        self.name: str = o_xtree.attrib.get("name", "Unnamed")
+        self.type: str = o_xtree.attrib.get(
+            "type", o_xtree.attrib.get("class", "Untyped")
+        )
+        self.px: float = float(o_xtree.attrib["x"])
+        self.py: float = float(o_xtree.attrib["y"])
+
+        tsource = o_xtree.attrib.get("template", None)
+        if tsource is not None:
+            tname = os.path.split(tsource)[-1].split(".")[0]
+            tpl: TiledTemplate = self.engine.assets.get_template(tname)
+
+            self.name = tpl.oname
+            self.type = tpl.otype
+            self.width = tpl.width
+            self.height = tpl.height
+            # Templates' y positions are bottom instead of top
+            self.py -= self.height
+
+            for key, prop in tpl.properties.items():
+                self.properties[key] = Property(
+                    name=prop.name, dtype=prop.dtype, value=prop.value
+                )
+
+            ts: TiledTileset = self.engine.assets.get_tileset(tpl.tileset_name)
+            self.properties["tileset_name"] = Property(
+                name="tileset_name", dtype="str", value=tpl.tileset_name
+            )
+            self.properties["image_name"] = Property(
+                name="image_name", dtype="str", value=ts.sprite_name
+            )
+            self.properties["sprite_offset_x"] = Property(
+                name="sprite_offset_x",
+                dtype="int",
+                value=f"{(tpl.gid - tpl.first_gid) % ts.columns}",
+            )
+
+            self.properties["sprite_offset_y"] = Property(
+                name="sprite_offset_y",
+                dtype="int",
+                value=f"{(tpl.gid - tpl.first_gid) // ts.columns}",
+            )
+        else:
+            self.width = float(o_xtree.attrib["width"])
+            self.height = float(o_xtree.attrib["height"])
+
+        if self.type == "container":
+            self.engine.total_chests += 1
+        props = o_xtree.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_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"],
+                )