mima-engine 0.1.0__py3-none-any.whl

mima/util/constants.py

@@ -0,0 +1,47 @@
+# Tile dimensions
+WIDTH: int = int(256 * 1)  # TODO: remove
+HEIGHT: int = int(144 * 1)  # TODO: remove
+TILE_WIDTH: int = 16
+TILE_HEIGHT: int = TILE_WIDTH
+DEFAULT_SPRITE_WIDTH: int = TILE_WIDTH
+DEFAULT_SPRITE_HEIGHT: int = TILE_HEIGHT
+UI_HIGHT: int = 1  # TODO: remove
+
+# Map transition
+MOVE_MAP_DURATION: float = 1.0
+MAP_TRANSITION_DURATION_FACTOR: float = 0.75
+ONEWAY_ACTIVATION_DELAY: float = 0.175
+ONEWAY_SPEED_BOOST: float = 2.0
+
+# Gamepad
+AXIS_DEADZONE: float = 0.25
+AXIS_ACTIVATION: float = 0.5
+
+# Touchscreen
+TOUCH_ACTIVATION: float = 0.001
+SINGLE_TAP_MIN: float = 0.2
+SINGLE_TAP_MAX: float = 1.0
+DOUBLE_TAP_SPEED: float = 0.2
+
+# Font
+BIG_FONT_NAME: str = "pixel-font"
+BIG_FONT_WIDTH: int = 6
+BIG_FONT_HEIGHT: int = 8
+SMALL_FONT_NAME: str = "pixel-font-small"
+SMALL_FONT_WIDTH: int = 4
+SMALL_FONT_HEIGHT: int = 5
+
+# Dynamics
+DEFAULT_GRAPHIC_TIMER_STANDING: float = 0.5
+DEFAULT_GRAPHIC_TIMER_WALKING: float = 0.15
+DEFAULT_GRAPHIC_TIMER_DAMAGED: float = 0.075
+DEFAULT_GRAPHIC_TIMER_DEAD: float = 0.25
+DEFAULT_GRAPHIC_TIMER: float = 0.5
+ATTRIBUTE_TIMER: float = 0.25
+DEFAULT_KNOCK_SPEED: float = 5.0
+
+# Gameplay
+ABYSS_DAMAGE: int = 1
+PLAYER_BASE_HEALTH: int = 30
+PLAYER_BASE_SPEED: float = 4.5
+PLAYER_BASE_RUN_SPEED: float = 6.0

mima/util/functions.py

@@ -0,0 +1,13 @@
+def strtobool(val: str) -> bool:
+    """Convert a string representation of truth to true (1) or false (0).
+    True values are 'y', 'yes', 't', 'true', 'on', and '1'; false values
+    are 'n', 'no', 'f', 'false', 'off', and '0'.  Raises ValueError if
+    'val' is anything else.
+    """
+    val = val.lower()
+    if val in ("y", "yes", "t", "true", "on", "1"):
+        return 1
+    elif val in ("n", "no", "f", "false", "off", "0", ""):
+        return 0
+    else:
+        raise ValueError("invalid truth value %r" % (val,))

mima/util/input_defaults.py

@@ -0,0 +1,49 @@
+from ..types.keys import Key as K
+
+BUTTONS = [
+    K.UP,
+    K.DOWN,
+    K.LEFT,
+    K.RIGHT,
+    K.START,
+    K.SELECT,
+    K.A,
+    K.B,
+    K.X,
+    K.Y,
+    K.L,
+    K.R,
+]
+
+
+# Keyboard
+# The arrow keys need to be uppercase, other keys are lowercase
+DEFAULT_KEYBOARD_MAP = {
+    K.UP: ["w", "UP"],
+    K.DOWN: ["s", "DOWN"],
+    K.LEFT: ["a", "LEFT"],
+    K.RIGHT: ["d", "RIGHT"],
+    K.START: ["i"],
+    K.SELECT: ["t"],
+    K.A: ["k"],
+    K.B: ["h"],
+    K.X: ["l"],
+    K.Y: ["j"],
+    K.L: ["o"],
+    K.R: ["c"],
+}
+
+DEFAULT_JOYSTICK_MAP = {
+    K.UP: ["up"],
+    K.DOWN: ["down"],
+    K.LEFT: ["left"],
+    K.RIGHT: ["right"],
+    K.START: [7],
+    K.SELECT: [6],
+    K.A: [0],
+    K.B: [1],
+    K.X: [3],
+    K.Y: [2],
+    K.L: [4],
+    K.R: [5],
+}

mima/util/logging.py

@@ -0,0 +1,51 @@
+import logging
+import logging.config
+
+_TRACE_INSTALLED = False
+_DEFAULT_CONFIG = {
+    "version": 1,
+    "formatters": {
+        "brief": {
+            "format": ("%(asctime)s [%(name)s][%(levelname)s] %(message)s")
+        },
+    },
+    "handlers": {
+        "console": {
+            "class": "logging.StreamHandler",
+            "formatter": "brief",
+            "level": "INFO",
+            "stream": "ext://sys.stdout",
+        },
+    },
+    "root": {
+        "level": "ERROR",
+        "handlers": ["console"],
+    },
+    "loggers": {
+        "mima": {"level": "TRACE"},
+    },
+}
+
+
+def install_trace_logger():
+    global _TRACE_INSTALLED
+    if _TRACE_INSTALLED:
+        return
+    level = logging.TRACE = logging.DEBUG - 5
+
+    def log_logger(self, message, *args, **kwargs):
+        if self.isEnabledFor(level):
+            self._log(level, message, args, **kwargs)
+
+    logging.getLoggerClass().trace = log_logger
+
+    def log_root(msg, *args, **kwargs):
+        logging.log(level, msg, *args, **kwargs)
+
+    logging.addLevelName(level, "TRACE")
+    logging.trace = log_root
+    _TRACE_INSTALLED = True
+
+
+def configure_logging(config=_DEFAULT_CONFIG):
+    logging.config.dictConfig(config)

mima/util/property.py

@@ -0,0 +1,8 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Property:
+    name: str
+    dtype: str
+    value: str

mima/util/runtime_config.py

@@ -0,0 +1,133 @@
+import configparser
+import os
+from copy import deepcopy
+from typing import Any, Dict
+
+from ..types.keys import Key as K
+from .colors import Color
+from .functions import strtobool
+
+DEFAULT_CONFIG = {
+    "keymap": {
+        "UP": "w",
+        "DOWN": "s",
+        "LEFT": "a",
+        "RIGHT": "d",
+        "A": "k",
+        "B": "h",
+        "X": "l",
+        "Y": "j",
+        "L": "o",
+        "R": "c",
+        "START": "i",
+        "SELECT": "t",
+    },
+    "colors": {
+        "gb_dark": "42,0,0",
+        "gb_medium_dark": "91,86,95",
+        "gb_medium_light": "186,191,181",
+        "gb_light": "255,255,241",
+    },
+    "flags": {"use_color": "false"},
+}
+
+
+class RuntimeConfig:
+    def __init__(self, config_path: str = ""):
+        self._loaded: Dict[str, Any] = deepcopy(DEFAULT_CONFIG)
+        self._converted: Dict[str, Any] = {}
+
+        if not config_path:
+            config_path = os.path.abspath(
+                os.path.join(os.getcwd(), "avenight.ini")
+            )
+
+        self._config_path = config_path
+        config = configparser.ConfigParser()
+
+        if os.path.exists(config_path):
+            config.read(config_path)
+
+            if config.sections():
+                self._read_config(config)
+
+            else:
+                self._write_config(config)
+
+        else:
+            self._write_config(config)
+
+    def _read_config(self, config: configparser.ConfigParser):
+        for key, mapping in config["keymap"].items():
+            vals = mapping.strip().split(",")
+            self._loaded["keymap"][key.upper()] = vals
+
+        self._loaded["colors"]["gb_dark"] = config["colors"]["gb_dark"]
+        self._loaded["colors"]["gb_medium_dark"] = config["colors"][
+            "gb_medium_dark"
+        ]
+        self._loaded["colors"]["gb_medium_light"] = config["colors"][
+            "gb_medium_light"
+        ]
+        self._loaded["colors"]["gb_light"] = config["colors"]["gb_light"]
+
+        self._loaded["flags"]["use_color"] = config["flags"]["use_color"]
+
+    def _write_config(self, config: configparser.ConfigParser):
+        config["keymap"] = {}
+        config["colors"] = {}
+        config["flags"] = {}
+        for key, mapping in self._loaded["keymap"].items():
+            config["keymap"][key.lower()] = mapping
+
+        config["colors"]["gb_dark"] = self._loaded["colors"]["gb_dark"]
+        config["colors"]["gb_medium_dark"] = self._loaded["colors"][
+            "gb_medium_dark"
+        ]
+        config["colors"]["gb_medium_light"] = self._loaded["colors"][
+            "gb_medium_light"
+        ]
+        config["colors"]["gb_light"] = self._loaded["colors"]["gb_light"]
+
+        config["flags"]["use_color"] = self._loaded["flags"]["use_color"]
+
+        with open(self._config_path, "w") as cfg_file:
+            config.write(cfg_file)
+
+    @property
+    def keymap(self):
+        if "keymap" in self._converted:
+            return self._converted["keymap"]
+        else:
+            self._converted["keymap"] = {}
+            for but in K:
+                self._converted["keymap"][but] = self._loaded["keymap"][
+                    but.name
+                ]
+
+        return self._converted["keymap"]
+
+    @property
+    def colors(self) -> Dict[str, Color]:
+        if "colors" in self._converted:
+            return self._converted["colors"]
+        else:
+            self._converted["colors"] = {}
+            for key, val in self._loaded["colors"].items():
+                self._converted["colors"][key] = Color(
+                    *[int(p) for p in val.strip().split(",")]
+                )
+
+            return self._converted["colors"]
+
+    @property
+    def flags(self) -> Dict[str, bool]:
+        if "flags" in self._converted:
+            return self._converted["flags"]
+        else:
+            self._converted["flags"] = {}
+            self._converted["flags"]["use_color"] = strtobool(
+                self._loaded["flags"]["use_color"]
+            )
+
+            return self._converted["flags"]

mima/view/camera.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ..util.constants import TILE_HEIGHT, TILE_WIDTH
+
+if TYPE_CHECKING:
+    from ..maps.tilemap import Tilemap
+    from ..objects.dynamic import Dynamic
+
+
+class Camera:
+    def __init__(
+        self,
+        visible_tiles_sx: int = 0,
+        visible_tiles_sy: int = 0,
+        visible_tiles_ex: Optional[int] = None,
+        visible_tiles_ey: Optional[int] = None,
+    ):
+        self.visible_tiles_sx: int = visible_tiles_sx
+        self.visible_tiles_sy: int = visible_tiles_sy
+        self.visible_tiles_ex: int = visible_tiles_ex
+        self.visible_tiles_ey: int = visible_tiles_ey
+
+        if self.visible_tiles_ex is None:
+            self.visible_tiles_ex = (
+                self.engine.backend.render_width / TILE_WIDTH
+                - self.visible_tiles_sx
+            )
+
+        if self.visible_tiles_ey is None:
+            self.visible_tiles_ey = (
+                self.engine.backend.render_height / TILE_HEIGHT
+                - self.visible_tiles_sy
+            )
+
+    def update(self, target: Dynamic, tilemap: Tilemap):
+
+        # Calculate x offset
+        self.ox = target.px - self.visible_tiles_ex / 2.0
+        self.ox = min(tilemap.width - self.visible_tiles_ex, max(0, self.ox))
+        if tilemap.width < self.visible_tiles_ex:
+            self.ox += (self.visible_tiles_ex - tilemap.width) / 2.0
+        self.ox -= self.visible_tiles_sx
+
+        # Calculate y offset
+        self.oy = target.py - self.visible_tiles_ey / 2.0
+        self.oy = min(tilemap.height - self.visible_tiles_ey, max(0, self.oy))
+        if tilemap.height < self.visible_tiles_ey:
+            self.oy += (self.visible_tiles_ey - tilemap.height) / 2.0
+        self.oy -= self.visible_tiles_sy