mima-engine 0.1.0__py3-none-any.whl

mima/scripts/commands/show_dialog.py

@@ -0,0 +1,11 @@
+from typing import List
+from ...scripts.command import Command
+
+
+class CommandShowDialog(Command):
+    def __init__(self, lines: List[str]):
+        super().__init__()
+        self.lines: List[str] = lines
+
+    def start(self):
+        self.engine.scene.show_dialog(self.lines)

mima/scripts/commands/take_coins.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Optional
+
+from ...scripts.command import Command
+
+if TYPE_CHECKING:
+    from ...objects.dynamic import Dynamic
+
+
+class CommandTakeCoins(Command):
+    def __init__(self, amount: int = 0, dynamic: Optional[Dynamic] = None):
+        super().__init__()
+
+        if dynamic is None:
+            dynamic = self.engine.player
+
+        self._amount: int = amount
+        self._dynamic: Dynamic = dynamic
+
+    def start(self):
+        self._dynamic.attributes.coins -= self._amount
+        self.completed = True

mima/scripts/script_processor.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+from .command import Command
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+
+
+class ScriptProcessor:
+    engine: MimaEngine
+
+    def __init__(self):
+        self.commands: List[Command] = []
+        self.user_control_enabled: bool = True
+
+    def add_command(self, cmd: Command):
+        self.commands.append(cmd)
+
+    def process_command(self, elapsed_time: float):
+        self.user_control_enabled = len(self.commands) == 0
+        if self.commands:
+            if not self.commands[0].completed:
+                if not self.commands[0].started:
+                    self.commands[0].start()
+                    self.commands[0].started = True
+                else:
+                    self.commands[0].update(elapsed_time)
+            else:
+                self.commands[0].finalize()
+                self.commands.pop(0)
+
+    def complete_command(self, force: bool = False):
+        if self.commands:
+            if self.commands[0].uninterruptible and not force:
+                return False
+            else:
+                self.commands[0].completed = True
+                return True

mima/states/game_state.py

@@ -0,0 +1,162 @@
+import json
+import logging
+import os
+from os import PathLike
+from typing import Any, Dict, List, Optional, Union
+
+from ..util.functions import strtobool
+
+LOG = logging.getLogger(__name__)
+
+
+class GameState:
+    def __init__(self, filename: PathLike):
+        self.filename = filename
+        self._state: Dict[str, Any] = {
+            "savefile_name": os.path.split(self.filename)[-1].split(".")[0]
+        }
+
+    def save_value(
+        self, key: str, value: Union[int, float, bool, str, dict, list]
+    ):
+        parts = key.split("__")
+        state = self._state
+        for idx, part in enumerate(parts):
+            if idx < len(parts) - 1:
+                state = state.setdefault(part, {})
+            else:
+                state[part] = value
+
+    def load_value(
+        self,
+        key: str,
+        default: Optional[Union[int, float, bool, str, dict, list]] = None,
+        astype: Optional[str] = None,
+    ) -> Optional[Union[int, float, bool, str, dict, list]]:
+        parts = key.split("__")
+        state = self._state
+        for idx, part in enumerate(parts):
+            if idx >= len(parts) - 1:
+                # state = state.get(part)
+                if state is None:
+                    return default
+                else:
+                    state = state.get(part)
+                    if state is None:
+                        return default
+                    if astype is not None:
+                        return convert(state, astype)
+                    return state
+
+            state = state.get(part)
+
+    def load_group(self, key: str, *more_keys: str):
+        data = self._state.get(key, {})
+        for key in more_keys:
+            data = data.get(key, {})
+        return data
+
+    def load_from_disk(self, autosave: bool = False):
+        filename = self.filename
+        if autosave:
+            filename = os.path.join(
+                os.path.split(filename)[0], "autosave.json"
+            )
+        try:
+            with open(filename, "r") as fp:
+                self._state = json.load(fp)
+        except FileNotFoundError:
+            LOG.info("No saved state found!")
+        except json.decoder.JSONDecodeError:
+            LOG.info("No saved state found or state corrupted.")
+
+        if autosave:
+            self.filename = os.path.join(
+                os.path.split(filename)[0],
+                f"{self._state['savefile_name']}.json",
+            )
+
+    def save_to_disk(self, autosave: bool = False):
+        filename = self.filename
+        if autosave:
+            filename = os.path.join(
+                os.path.split(filename)[0], "autosave.json"
+            )
+            self.save_value("player__pos_x", 5.0)
+            self.save_value("player__pos_y", 5.0)
+            self.save_value(
+                "player__map_name", self.load_value("player__spawn_map")
+            )
+        else:
+            self._state["savefile_name"] = os.path.split(filename)[-1].split(
+                "."
+            )[0]
+            # Auto save file will be removed after a successful save
+            try:
+                os.remove(
+                    os.path.join(os.path.split(filename)[0], "autosave.json")
+                )
+            except FileNotFoundError:
+                pass
+
+        with open(filename, "w") as fp:
+            json.dump(self._state, fp, sort_keys=False, indent=4)
+
+    def delete_keys(self, scope, keypart, exceptions):
+        k2d = []
+        for k in self._state[scope]:
+            if keypart in k and k not in exceptions:
+                k2d.append(k)
+        for k in k2d:
+            del self._state[scope][k]
+
+
+def convert(value, astype):
+    if astype == "int":
+        try:
+            return int(value)
+        except TypeError:
+            return value
+    if astype == "float":
+        try:
+            return float(value)
+        except TypeError:
+            return value
+    if astype == "bool":
+        try:
+            return strtobool(value)
+        except AttributeError:
+            value
+    return value
+
+
+def load_saved_games(save_path, save_file_name):
+    all_games = {}
+    if not os.path.isdir(save_path):
+        LOG.warning(f"Save folder does not exist: {save_path}")
+        return all_games
+
+    files = os.listdir(save_path)
+    if not files:
+        LOG.info(f"No save files found at {save_path}")
+        return all_games
+
+    if "autosave.json" in files:
+        all_games["autosave"] = GameState(
+            os.path.join(save_path, "autosave.json")
+        )
+        all_games["autosave"].load_from_disk(autosave=True)
+        LOG.debug("Loading saved game from autosave.json")
+
+    game_idx = 0
+    while True:
+        savegame = f"{save_file_name}{game_idx:03d}.json"
+        if savegame in files:
+            all_games[savegame] = GameState(os.path.join(save_path, savegame))
+            all_games[savegame].load_from_disk()
+            LOG.debug(f"Loading saved game from {savegame}")
+        game_idx += 1
+        if game_idx >= len(files):
+            break
+
+    return all_games

mima/states/quest.py

@@ -0,0 +1,72 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List
+
+from ..util.functions import strtobool
+
+if TYPE_CHECKING:
+    from ..engine.mima_engine import MimaEngine
+    from ..objects.dynamic import Dynamic
+    from ..types.nature import Nature
+
+
+class Quest:
+    engine: MimaEngine
+
+    def __init__(self):
+        self.name: str = "Unnamed Quest"
+        self.accepted: bool = False
+        self.reward_unlocked: bool = False
+        self.reward_received: bool = False
+        self.completed: bool = False
+        self.state: int = 0
+
+    def on_interaction(
+        self, dynamics: List[Dynamic], target: Dynamic, nature: Nature
+    ):
+        return False
+
+    def populate_dynamics(self, dynamics: List[Dynamic], map_name: str):
+        return False
+
+    def load_state(self):
+        state = self.engine.game_state.load_group("quest", self.name)
+        # key = f"quest__{self.name}__"
+        self.accepted = state.get("accepted", False)
+        self.reward_unlocked = state.get("reward_unlocked", False)
+        self.reward_received = state.get("reward_received", False)
+        self.completed = state.get("completed", False)
+        self.state = state.get("state", 0)
+
+    def save_state(self):
+        key = f"quest__{self.name}__"
+        self.clean_up()
+        self.engine.game_state.save_value(f"{key}accepted", self.accepted)
+        self.engine.game_state.save_value(f"{key}completed", self.completed)
+        self.engine.game_state.save_value(
+            f"{key}reward_received", self.reward_received
+        )
+        self.engine.game_state.save_value(
+            f"{key}reward_unlocked", self.reward_unlocked
+        )
+        self.engine.game_state.save_value(f"{key}state", self.state)
+
+    def clean_up(self):
+        if self.accepted is None or not isinstance(self.accepted, bool):
+            self.accepted = False
+
+        if self.completed is None or not isinstance(self.completed, bool):
+            self.completed = False
+
+        if self.reward_unlocked is None or not isinstance(
+            self.reward_unlocked, bool
+        ):
+            self.reward_unlocked = False
+
+        if self.reward_received is None or not isinstance(
+            self.reward_received, bool
+        ):
+            self.reward_received = False
+
+        if self.state is None or not isinstance(self.state, int):
+            self.state = 0

mima/types/alignment.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class Alignment(Enum):
+    GOOD = 0
+    NEUTRAL = 1
+    EVIL = 2

mima/types/blend.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class Blend(Enum):
+    DEFAULT = 0
+    ADD = 1
+    SUB = 2
+    MULT = 3

mima/types/damage.py

@@ -0,0 +1,42 @@
+from enum import Enum
+
+
+class Damage(Enum):
+    NO_DAMAGE = 0
+    BODY = 1
+    SLICING = 2
+    PIERCING = 3
+    HEAVY = 4
+    EXPLOSION = 5
+    MAGIC = 6
+    FIRE = 7
+    WATER = 8
+    WIND = 9
+    EARTH = 10
+    HEAL = 11
+    DARK = 12
+    FRONT = 13
+    SIDE = 14
+    BACK = 15
+
+
+PHYSICAL = [
+    Damage.BODY,
+    Damage.SLICING,
+    Damage.PIERCING,
+    Damage.HEAVY,
+    Damage.EXPLOSION,
+    Damage.FRONT,
+    Damage.SIDE,
+    Damage.BACK,
+]
+
+MAGICAL = [
+    Damage.MAGIC,
+    Damage.FIRE,
+    Damage.WATER,
+    Damage.WIND,
+    Damage.EARTH,
+    Damage.HEAL,
+    Damage.DARK,
+]

mima/types/direction.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Tuple
+
+
+class Direction(Enum):
+    SOUTH = 0
+    WEST = 1
+    NORTH = 2
+    EAST = 3
+
+    def from_velocity(vx: float, vy: float):
+        direction = None
+        if abs(vx) >= abs(vy):
+            if vx > 0:
+                direction = Direction.EAST
+            elif vx < 0:
+                direction = Direction.WEST
+            else:
+                # TODO: Check for up and down
+                pass
+        elif abs(vx) < abs(vy):
+            if vy > 0:
+                direction = Direction.SOUTH
+            elif vy < 0:
+                direction = Direction.NORTH
+            else:
+                # TODO: Check for left and right
+                pass
+        return direction
+
+    def to_velocity(direction: Direction) -> Tuple[int, int]:
+        vx = vy = 0
+
+        if direction == Direction.SOUTH:
+            vy = 1
+        elif direction == Direction.EAST:
+            vx = 1
+        elif direction == Direction.NORTH:
+            vy = -1
+        elif direction == Direction.WEST:
+            vx = -1
+        return vx, vy

mima/types/gate_color.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class GateColor(Enum):
+    RED = 0
+    GREEN = 1
+    BLUE = 2

mima/types/graphic_state.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+
+class GraphicState(Enum):
+    STANDING = 0
+    WALKING = 1
+    ATTACKING = 2
+    DAMAGED = 3
+    CELEBRATING = 4
+    DEAD = 5
+    DEFEATED = 6
+    PUSHING = 7
+    OPEN = 8
+    CLOSED = 9
+    LOCKED = 10
+    OFF = 11
+    ON = 12
+
+
+class Until(Enum):
+    UNLOCK = 0
+    NEXT_UPDATE = 1

mima/types/keys.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+
+class Key(Enum):
+    UP = 0
+    DOWN = 1
+    LEFT = 2
+    RIGHT = 3
+    A = 4
+    B = 5
+    X = 6
+    Y = 7
+    R = 8
+    L = 9
+    START = 10
+    SELECT = 11

mima/types/mode.py

@@ -0,0 +1,15 @@
+from enum import Enum
+
+
+class Mode(Enum):
+    LOADING = 0
+    TITLE = 1
+    SELECT_GAME = 2
+    LOCAL_MAP = 3
+    WORLD_MAP = 4
+    INVENTORY = 5
+    SHOP = 6
+    GAME_OVER = 7
+    TITLE_SETTINGS = 8
+    CONTROLS = 9
+    COMBAT = 10

mima/types/nature.py

@@ -0,0 +1,12 @@
+from enum import Enum
+
+
+class Nature(Enum):
+    WALK = 0
+    TALK = 1
+    ATTACK = 2
+    KILLED = 3
+    SIGNAL = 4
+    NO_SIGNAL = 5
+    SAVE = 6
+    LOAD = 7

mima/types/object.py

@@ -0,0 +1,22 @@
+from enum import Enum
+
+
+class ObjectType(Enum):
+    UNDEFINED = -1
+    PLAYER = 0
+    DYNAMIC = 1
+    PROJECTILE = 2
+    CREATURE = 3
+    SCRIPTED_CREATURE = 4
+    TELEPORT = 5
+    PICKUP = 6
+    MOVABLE = 7
+    GATE = 8
+    CONTAINER = 9
+    SWITCH = 10
+    FLOOR_SWITCH = 11
+    ONEWAY = 12
+    LOGIC_GATE = 13
+    LIGHT_SOURCE = 14
+    COLOR_SWITCH = 15
+    COLOR_GATE = 16

mima/types/start.py

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class Start:
+    NEW = 0
+    LOAD = 1
+    GAME_OVER = 2

mima/types/terrain.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class Terrain(Enum):
+    DEFAULT = 0
+    GRASS = 1
+    SHALLOW_WATER = 2
+    DEEP_WATER = 3
+    OCEAN = 4

mima/types/weapon_slot.py

@@ -0,0 +1,6 @@
+from enum import Enum
+
+
+class WeaponSlot(Enum):
+    FIRST_HAND = 0
+    SECOND_HAND = 1

mima/usables/item.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+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, name: str, sprite_name: str, description: str):
+        self.name: str = name
+        self.description: str = description
+        self.sprite_name: str = sprite_name
+        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
+
+    def on_interaction(self, obj: Dynamic):
+        return False
+
+    def on_use(self, obj: Creature):
+        return False

mima/usables/weapon.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, 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, name: str, sprite: str, description: str):
+        super().__init__(name, sprite, description)
+
+        self.equipable = True
+
+        self.damage: int = 0
+        self.dtype: Damage = Damage.BODY
+        self.health_cost: int = 0
+        self.magic_cost: int = 0
+        self.stamina_cost: int = 0
+        self.arrow_cost: int = 0
+        self.bomb_cost: int = 0
+        self.swing_timer: int = 0.2
+        # self.projectiles: List[Projectile] = []
+
+    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

mima/util/__init__.py

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

mima/util/colors.py

@@ -0,0 +1,45 @@
+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)