mima-engine 0.4.0__py3-none-any.whl

mima/usables/item.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict
+
+from ..util.constants import DEFAULT_SPRITE_HEIGHT, DEFAULT_SPRITE_WIDTH
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+    from ..objects.creature import Creature
+    from ..objects.dynamic import Dynamic
+
+
+class Item:
+    engine: MimaEngine
+
+    def __init__(self):
+        self.name: str = ""
+        self.description: str = ""
+        self.sprite_name: str = ""
+        # self.sprite_ox: int = 0
+        # self.sprite_oy: int = 0
+        # self.sprite_width: int = DEFAULT_SPRITE_WIDTH
+        # self.sprite_height: int = DEFAULT_SPRITE_HEIGHT
+        self.key_item: bool = False
+        self.equipable: bool = False
+        self.price: int = 0
+        self.stackable: bool = False
+        self.stackable_by_merchant: bool = False
+
+    def init(self, data: Dict[str, Any]):
+
+        for key, val in data.items():
+            setattr(self, key, val)
+        # self.usable_id = data["usable_id"]
+        # self.name = data["name"]
+        # self.description = data["description"]
+        # self.price = data.get("attr_price", 0)
+        # self.sprite_name = data.get("sprite_name")
+
+    def on_interaction(self, obj: Dynamic):
+        return False
+
+    def on_use(self, obj: Creature):
+        return False
+
+    def __str__(self):
+        txt = f"{type(self).__name__}({self.name})"
+        return txt
+
+    def __repr__(self):
+        return str(self)

mima/usables/weapon.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Tuple
+
+from ..types.damage import Damage
+from ..types.direction import Direction
+from .item import Item
+
+if TYPE_CHECKING:
+    from ..objects.creature import Creature
+
+
+class Weapon(Item):
+    def __init__(self):
+        super().__init__()
+
+        self.equipable = True
+
+        self.damage: int = 0
+        self.dtype: Damage = Damage.BODY
+        self.health_cost: float = 0.0
+        self.magic_cost: float = 0.0
+        self.stamina_cost: float = 0.0
+        self.arrow_cost: int = 0
+        self.bomb_cost: int = 0
+        self.swing_timer: float = 0.2
+
+    def init(self, data: Dict[str, Any]):
+        for key, val in data.items():
+            setattr(self, key, val)
+        # self.usable_id = data["usable_id"]
+        # self.name = data["display_name"]
+        # self.description = data["description"]
+        # self.sprite_name = data["sprite_name"]
+        # self.price = data["attr_price"]
+        # self.swing_timer = data["attr_swing_timer"]
+        # self.damage = data["attr_damage"]
+        # self.dtype = data["attr_dtype"]
+        # self.health_cost = data["attr_health_cost"]
+        # self.magic_cost = data["attr_magic_cost"]
+        # self.stamina_cost = data["attr_stamina_cost"]
+        # self.bomb_cost = data["attr_bomb_cost"]
+        # self.arrow_cost = data["attr_arrow_cost"]
+        # print()
+
+    def _determine_attack_origin(self, obj: Creature) -> Tuple[float, float]:
+        vx = 0.0
+        vy = 0.0
+
+        if obj.facing_direction == Direction.SOUTH:
+            vy = 1.0
+        if obj.facing_direction == Direction.WEST:
+            vx = -1.0
+        if obj.facing_direction == Direction.NORTH:
+            vy = -1.0
+        if obj.facing_direction == Direction.EAST:
+            vx = 1.0
+
+        return vx, vy
+
+    def on_equip(self, obj: Creature):
+        pass
+
+    def on_unequip(self, obj: Creature):
+        pass
+
+    def on_interaction(self, target: Creature):
+        return True  # Add to inventory

mima/util/__init__.py

@@ -0,0 +1 @@
+from .runtime_config import RuntimeConfig

mima/util/colors.py

@@ -0,0 +1,50 @@
+from typing import Tuple
+
+
+class Color:
+    def __init__(self, red: int, green: int, blue: int, alpha: int = 255):
+        self.red = red
+        self.green = green
+        self.blue = blue
+        self.alpha = alpha
+
+    def getRGBA(self) -> Tuple[int, int, int, int]:
+        return (self.red, self.green, self.blue, self.alpha)
+
+    def getRGB(self) -> Tuple[int, int, int]:
+        return (self.red, self.green, self.blue)
+
+    def __repr__(self):
+        return (
+            f"Color(red={self.red}, green={self.green}, "
+            f"blue={self.blue}, alpha={self.alpha})"
+        )
+
+    def short_name(self):
+        return f"{self.red}-{self.green}-{self.blue}-{self.alpha}"
+
+
+BLACK = Color(0, 0, 0)
+WHITE = Color(255, 255, 255)
+ALPHA = Color(254, 253, 254)
+LIGHTGREY = Color(100, 100, 100)
+DARK_GREY = Color(64, 64, 64, 160)
+VERY_LIGHT_GREY = Color(195, 195, 195)
+RED = Color(255, 0, 0)
+GREEN = Color(0, 255, 0)
+BLUE = Color(0, 0, 255)
+YELLOW = Color(255, 255, 0)
+CYAN = Color(0, 255, 255)
+PURPLE = Color(128, 0, 128)
+DARK_RED = Color(64, 0, 0, 160)
+DARK_GREEN = Color(0, 64, 0, 160)
+DARK_BLUE = Color(0, 0, 64, 160)
+DARK_YELLOW = Color(64, 64, 0, 160)
+DARK_CYAN = Color(0, 64, 64, 160)
+DARK_PURPLE = Color(64, 0, 64, 160)
+TRANS_CYAN = Color(0, 64, 64, 128)
+TRANS_LIGHT_RED = Color(255, 0, 0, 128)
+TRANS_LIGHT_YELLOW = Color(255, 255, 0, 128)
+TRANS_LIGHT_CYAN = Color(0, 255, 255, 128)
+TRANS_LIGHT_PURPLE = Color(255, 0, 255, 128)
+TRANS_LIGHT_GREEN = Color(0, 255, 0, 128)

mima/util/constants.py

@@ -0,0 +1,55 @@
+# 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.075
+ONEWAY_SPEED_BOOST: float = 2.5
+
+# 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 = 6.0
+
+# Gameplay
+ABYSS_DAMAGE: int = 1
+PLAYER_BASE_HEALTH: int = 30
+PLAYER_BASE_SPEED: float = 4.5
+PLAYER_BASE_RUN_SPEED: float = 6.0
+
+# Dialog
+DIALOG_WIDTH: float = 14.0
+DIALOG_HEIGHT: float = 3.0
+DIALOG_CHARS_PER_LINE: int = 36
+DIALOG_N_LINES: int = 4
+
+SAVE_FILE_NAME = "savegame"

mima/util/functions.py

@@ -0,0 +1,38 @@
+from .constants import BIG_FONT_WIDTH
+
+
+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 True
+    elif val in ("n", "no", "f", "false", "off", "0", ""):
+        return False
+    else:
+        raise ValueError("invalid truth value %r" % (val,))
+
+
+def wrap_text(text: str, n_chars: int = 0) -> list[str]:
+    if n_chars == 0:
+        return [text]
+
+    words = text.split(" ")
+    lines: list[str] = []
+    new_text = ""
+    for idx, word in enumerate(words):
+        if len(new_text + word) > n_chars:
+            lines.append(new_text)
+            new_text = ""
+
+        new_text += f"{word.strip()} "
+    # new_text.strip()
+    lines.append(new_text.strip())
+    return lines
+
+
+def text_to_center(text: str, ppx: int, pwidth: int, font_width=BIG_FONT_WIDTH):
+    return int(ppx + pwidth / 2 - (len(text) / 2 * BIG_FONT_WIDTH))

mima/util/input_defaults.py

@@ -0,0 +1,170 @@
+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,
+    K.P1_UP,
+    K.P1_DOWN,
+    K.P1_LEFT,
+    K.P1_RIGHT,
+    K.P1_START,
+    K.P1_SELECT,
+    K.P1_A,
+    K.P1_B,
+    K.P1_X,
+    K.P1_Y,
+    K.P1_L,
+    K.P1_R,
+    K.P2_UP,
+    K.P2_DOWN,
+    K.P2_LEFT,
+    K.P2_RIGHT,
+    K.P2_START,
+    K.P2_SELECT,
+    K.P2_A,
+    K.P2_B,
+    K.P2_X,
+    K.P2_Y,
+    K.P2_L,
+    K.P2_R,
+    K.P3_UP,
+    K.P3_DOWN,
+    K.P3_LEFT,
+    K.P3_RIGHT,
+    K.P3_START,
+    K.P3_SELECT,
+    K.P3_A,
+    K.P3_B,
+    K.P3_X,
+    K.P3_Y,
+    K.P3_L,
+    K.P3_R,
+    K.P4_UP,
+    K.P4_DOWN,
+    K.P4_LEFT,
+    K.P4_RIGHT,
+    K.P4_START,
+    K.P4_SELECT,
+    K.P4_A,
+    K.P4_B,
+    K.P4_X,
+    K.P4_Y,
+    K.P4_L,
+    K.P4_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"],
+    K.P1_UP: [],
+    K.P1_DOWN: [],
+    K.P1_LEFT: [],
+    K.P1_RIGHT: [],
+    K.P1_START: [],
+    K.P1_SELECT: [],
+    K.P1_A: [],
+    K.P1_B: [],
+    K.P1_X: [],
+    K.P1_Y: [],
+    K.P1_L: [],
+    K.P1_R: [],
+    K.P1_UP: [],
+    K.P1_UP: [],
+    K.P2_DOWN: [],
+    K.P2_LEFT: [],
+    K.P2_RIGHT: [],
+    K.P2_START: [],
+    K.P2_SELECT: [],
+    K.P2_A: [],
+    K.P2_B: [],
+    K.P2_X: [],
+    K.P2_Y: [],
+    K.P2_L: [],
+    K.P2_R: [],
+    K.P2_UP: [],
+    K.P3_UP: [],
+    K.P3_DOWN: [],
+    K.P3_LEFT: [],
+    K.P3_RIGHT: [],
+    K.P3_START: [],
+    K.P3_SELECT: [],
+    K.P3_A: [],
+    K.P3_B: [],
+    K.P3_X: [],
+    K.P3_Y: [],
+    K.P3_L: [],
+    K.P3_R: [],
+    K.P4_UP: [],
+    K.P4_DOWN: [],
+    K.P4_LEFT: [],
+    K.P4_RIGHT: [],
+    K.P4_START: [],
+    K.P4_SELECT: [],
+    K.P4_A: [],
+    K.P4_B: [],
+    K.P4_X: [],
+    K.P4_Y: [],
+    K.P4_L: [],
+    K.P4_R: [],
+}
+
+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],
+}
+
+DEFAULT_TOUCHSCREEN_MAP = {
+    K.P1_UP: [[0, 0], [0.5, 1.0]],
+    K.P1_L: [[0, 0], [0.0625, 0.1111]],
+    K.P1_R: [[0.9375, 0], [1.0, 0.1111]],
+    K.P1_START: [[0.5, 0], [1.0, 0.3]],
+    K.P1_Y: [[0.5, 0.3], [0.75, 0.5]],
+    K.P1_X: [[0.75, 0.3], [1.0, 0.5]],
+    K.P1_B: [[0.5, 0.5], [0.75, 1.0]],
+    K.P1_A: [[0.75, 0.5], [1.0, 1.0]],
+}
+
+ALT_TOUCHSCREEN_MAP = {
+    K.P1_UP: {"pos": [0.1, 0.2], "size": [0.4, 0.7]},
+    K.P1_A: {"pos": [0.83, 0.80], "size": [0.15, 0.15]},
+    K.P1_B: {"pos": [0.67, 0.80], "size": [0.15, 0.15]},
+    K.P1_X: {"pos": [0.83, 0.65], "size": [0.12, 0.12]},
+    K.P1_Y: {"pos": [0.70, 0.65], "size": [0.12, 0.12]},
+    K.P1_START: {"pos": [0.56, 0.02], "size": [0.1, 0.1]},
+    K.P1_SELECT: {"pos": [0.34, 0.02], "size": [0.1, 0.1]},
+    K.P1_L: {"pos": [0.01, 0.1], "size": [0.05, 0.4]},
+    K.P1_R: {"pos": [0.94, 0.1], "size": [0.05, 0.4]},
+}

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