mima-engine 0.4.0__py3-none-any.whl

mima/layered/virtual_input.py

@@ -0,0 +1,302 @@
+import logging
+import time
+from dataclasses import dataclass
+
+import pygame
+from typing_extensions import Iterable, Protocol, TypeAlias
+
+from mima.standalone.user_input import Input, InputManager, Player
+
+LOG = logging.getLogger(__name__)
+
+
+class InputResolver(Protocol):
+    def resolve(self, im: InputManager, player: Player): ...
+
+
+@dataclass(frozen=True)
+class AnalogDirectionSource:
+    x: Input | None
+    y: Input | None
+
+
+@dataclass(frozen=True)
+class DigitalDirectionSource:
+    left: Input
+    right: Input
+    up: Input
+    down: Input
+
+
+DirectionSource: TypeAlias = AnalogDirectionSource | DigitalDirectionSource
+
+
+class DirectionResolver:
+    """Resolves directional intent as a Vector2.
+
+    Resolution order is significant, first non-zero source wins.
+    """
+
+    def __init__(
+        self,
+        sources: Iterable[DirectionSource],
+        deadzone: float = 0.5,
+        normalize: bool = True,
+    ) -> None:
+        self.sources = tuple(sources)
+        self.deadzone = deadzone
+        self.normalize = normalize
+
+    def resolve(self, im: InputManager, player: Player = Player.P1) -> pygame.Vector2:
+        for src in self.sources:
+            if isinstance(src, AnalogDirectionSource):
+                vec = self._resolve_analog(im, player, src)
+            else:
+                vec = self._resolve_digital(im, player, src)
+
+            if vec.length_squared() > 0:
+                if self.normalize and vec.length_squared() > 1:
+                    vec = vec.normalize()
+                return vec
+
+        return pygame.Vector2()
+
+    def _resolve_analog(
+        self, im: InputManager, player: Player, src: AnalogDirectionSource
+    ) -> pygame.Vector2:
+        x = im.value(src.x, player) if src.x else 0.0
+        y = im.value(src.y, player) if src.y else 0.0
+
+        if abs(x) < self.deadzone:
+            x = 0.0
+        if abs(y) < self.deadzone:
+            y = 0.0
+
+        return pygame.Vector2(x, y)
+
+    def _resolve_digital(
+        self, im: InputManager, player: Player, src: DigitalDirectionSource
+    ) -> pygame.Vector2:
+        x = (1 if im.held(src.right, player) else 0) - (
+            1 if im.held(src.left, player) else 0
+        )
+        y = (1 if im.held(src.down, player) else 0) - (
+            1 if im.held(src.up, player) else 0
+        )
+        return pygame.Vector2(x, y)
+
+
+class ButtonGroupResolver:
+    """Resolves a logical button as active if ANY source is active."""
+
+    def __init__(self, *inputs: Input) -> None:
+        self.inputs = inputs
+
+    def pressed(self, im: InputManager, player: Player = Player.P1) -> bool:
+        return any(im.pressed(i, player) for i in self.inputs)
+
+    def held(self, im: InputManager, player: Player = Player.P1) -> bool:
+        return any(im.held(i, player) for i in self.inputs)
+
+    def released(self, im: InputManager, player: Player = Player.P1) -> bool:
+        return any(im.released(i, player) for i in self.inputs)
+
+
+class AxisSnapResolver:
+    """Converts an axis into digital directions.
+
+    The AxisSnapResolver allows analog sticks to behave like digital buttons, making
+    them suitable for menus, grids, and UI navigation while preserving unified input
+    semantics across keyboard, D-Pad, and controller.
+
+    """
+
+    def __init__(
+        self, axis: Input, negative: Input, positive: Input, deadzone: float = 0.5
+    ) -> None:
+        self.axis = axis
+        self.negative = negative
+        self.positive = positive
+        self.deadzone = deadzone
+        self._last_value: float = 0.0
+
+    def resolve(self, im: InputManager, player: Player = Player.P1) -> set[Input]:
+        value = im.value(self.axis, player)
+        result: set[Input] = set()
+
+        if value <= -self.deadzone and self._last_value > -self.deadzone:
+            result.add(self.negative)
+        elif value >= self.deadzone and self._last_value < self.deadzone:
+            result.add(self.positive)
+
+        self._last_value = value
+
+        return result
+
+
+# def load_direction_resolver(data: dict) -> DirectionResolver:
+#     """TODO:"""
+#     sources = [
+#         AnalogDirectionSource(
+#             Input[src["x"]] if src.get("x") else None,
+#             Input[src["y"]] if src.get("y") else None,
+#         )
+#         for src in data["sources"]
+#     ]
+
+#     return DirectionResolver(
+#         sources=sources,
+#         deadzone=data.get("deadzone", 0.5),
+#         normalize=data.get("normalize", True),
+#     )
+
+
+MOVE_DIRECTION = DirectionResolver(
+    sources=[
+        AnalogDirectionSource(Input.LEFT_STICK_X, Input.LEFT_STICK_Y),
+        DigitalDirectionSource(
+            left=Input.DPAD_LEFT,
+            right=Input.DPAD_RIGHT,
+            up=Input.DPAD_UP,
+            down=Input.DPAD_DOWN,
+        ),
+        DigitalDirectionSource(
+            left=Input.LEFT, right=Input.RIGHT, up=Input.UP, down=Input.DOWN
+        ),
+    ]
+)
+
+KEYBOARD_MOVE = DirectionResolver(
+    sources=[
+        DigitalDirectionSource(
+            left=Input.LEFT, right=Input.RIGHT, up=Input.UP, down=Input.DOWN
+        )
+    ]
+)
+
+CONTROLLER_MOVE = DirectionResolver(
+    sources=[
+        AnalogDirectionSource(Input.LEFT_STICK_X, Input.LEFT_STICK_Y),
+        DigitalDirectionSource(
+            left=Input.DPAD_LEFT,
+            right=Input.DPAD_RIGHT,
+            up=Input.DPAD_UP,
+            down=Input.DPAD_DOWN,
+        ),
+    ]
+)
+
+MENU_MOVE_X = AxisSnapResolver(
+    axis=Input.LEFT_STICK_X, negative=Input.LEFT, positive=Input.RIGHT, deadzone=0.25
+)
+
+MENU_MOVE_Y = AxisSnapResolver(
+    axis=Input.LEFT_STICK_Y, negative=Input.UP, positive=Input.DOWN, deadzone=0.25
+)
+
+
+def resolve_menu_directions(im: InputManager, player: Player = Player.P1) -> set[Input]:
+    directions: set[Input] = set()
+
+    # Analog stick -> digital
+    directions |= MENU_MOVE_X.resolve(im, player)
+    directions |= MENU_MOVE_Y.resolve(im, player)
+
+    # D-Pad and keyboard
+    if im.pressed(Input.DPAD_UP, player) or im.pressed(Input.UP):
+        directions.add(Input.UP)
+    if im.pressed(Input.DPAD_DOWN, player) or im.pressed(Input.DOWN):
+        directions.add(Input.DOWN)
+    if im.pressed(Input.DPAD_LEFT, player) or im.pressed(Input.LEFT):
+        directions.add(Input.LEFT)
+    if im.pressed(Input.DPAD_RIGHT, player) or im.pressed(Input.RIGHT):
+        directions.add(Input.RIGHT)
+
+    return directions
+
+
+@dataclass
+class MenuNavConfig:
+    initial_delay: float = 0.4
+    repeat_interval: float = 0.1
+    axis_threshold: float = 0.6
+
+
+class MenuNavigationResolver:
+    """Resolves menu navigation intent from keyboard, d-pad, and stick."""
+
+    def __init__(self, config: MenuNavConfig | None = None) -> None:
+        self.config = config or MenuNavConfig()
+
+        # Per-player, per-direction state
+        self._held_since: dict[tuple[Player, Input], float] = {}
+        self._last_emit: dict[tuple[Player, Input], float] = {}
+
+    def resolve(self, im: InputManager, player: Player = Player.P1) -> set[Input]:
+        now = time.monotonic()
+        result: set[Input] = set()
+
+        # Collect raw directional state
+        active = self._collect_active_directions(im, player)
+
+        # Resolve edge and repeat
+        for direction in active:
+            key = (player, direction)
+
+            if key not in self._held_since:
+                # Fresh press
+                self._held_since[key] = now
+                self._last_emit[key] = now
+                result.add(direction)
+                continue
+
+            held_time = now - self._held_since[key]
+            since_last = now - self._last_emit[key]
+
+            if held_time >= self.config.initial_delay:
+                if since_last >= self.config.repeat_interval:
+                    self._last_emit[key] = now
+                    result.add(direction)
+
+        # Clear released directions
+        released = set(self._held_since.keys()) - {(player, d) for d in active}
+        for key in released:
+            self._held_since.pop(key, None)
+            self._last_emit.pop(key, None)
+
+        return result
+
+    def _collect_active_directions(
+        self, im: InputManager, player: Player
+    ) -> set[Input]:
+        result: set[Input] = set()
+
+        # D-Pad and keyboard
+        if im.held(Input.DPAD_UP, player) or im.held(Input.UP):
+            result.add(Input.UP)
+        if im.held(Input.DPAD_DOWN, player) or im.held(Input.DOWN):
+            result.add(Input.DOWN)
+        if im.held(Input.DPAD_LEFT, player) or im.held(Input.LEFT):
+            result.add(Input.LEFT)
+        if im.held(Input.DPAD_RIGHT, player) or im.held(Input.RIGHT):
+            result.add(Input.RIGHT)
+
+        # Stick (snapped)
+        x = im.value(Input.LEFT_STICK_X, player)
+        y = im.value(Input.LEFT_STICK_Y, player)
+
+        if x <= -self.config.axis_threshold:
+            result.add(Input.LEFT)
+        elif x >= self.config.axis_threshold:
+            result.add(Input.RIGHT)
+        if y <= -self.config.axis_threshold:
+            result.add(Input.UP)
+        elif y >= self.config.axis_threshold:
+            result.add(Input.DOWN)
+
+        return result
+
+
+MENU_NAV = MenuNavigationResolver(
+    MenuNavConfig(initial_delay=0.35, repeat_interval=0.08, axis_threshold=0.65)
+)

mima/maps/template.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, Optional, Union
+
+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
+
+    def get(
+        self, key: str, default_val: Optional[str, int, float, bool] = None
+    ) -> Union[str, int, float, bool]:
+
+        if key in self.properties:
+            if self.properties[key].dtype == "str":
+                if default_val is None:
+                    return self.get_string(key)
+                return self.get_string(key, default_val)
+            if self.properties[key].dtype == "int":
+                if default_val is None:
+                    return self.get_int(key)
+                return self.get_int(key, int(default_val))
+            if self.properties[key].dtype == "float":
+                if default_val is None:
+                    return self.get_float(key)
+                return self.get_float(key, float(default_val))
+            if self.properties[key].dtype == "bool":
+                if default_val is None:
+                    return self.get_bool(key)
+                elif not isinstance(default_val, bool):
+                    msg = (
+                        "Trying to access a bool value but default value "
+                        f"{default_val} is of type {type(default_val)}"
+                    )
+                    raise TypeError(msg)
+                return self.get_bool(key, default_val)
+
+        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 ...util.property import Property
+from ..tilemap import Tilemap
+from ..tileset_info import TilesetInfo
+from .tiled_layer import TiledLayer
+from .tiled_objectgroup import TiledObjectgroup
+
+# 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=""
+            )
+            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"],
+                )