mima-engine 0.4.0__py3-none-any.whl

mima/states/game_state.py

@@ -0,0 +1,189 @@
+import json
+import logging
+import os
+from os import PathLike
+from pathlib import Path
+from typing import Any, Dict, Union
+
+# from typing_extensions import overload
+from ..util.constants import SAVE_FILE_NAME
+from ..util.functions import strtobool
+
+LOG = logging.getLogger(__name__)
+
+
+class GameState:
+    def __init__(self, save_path: PathLike, state_name: str = "autosave.json"):
+        self.state_name = state_name
+        self._save_path = save_path
+        self._state: Dict[str, Any] = {}
+
+    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
+
+    # @overload
+    # def load_value(
+    #     self, key: str, default: str, astype: str | None
+    # ) -> str | None: ...
+
+    # @overload
+    # def load_value(
+    #     self, key: str, default: int, astype: str | None
+    # ) -> int | None: ...
+
+    def load_value(
+        self,
+        key: str,
+        default: int | float | bool | str | dict | list | None = None,
+        astype: str | None = None,
+    ) -> int | float | bool | str | dict | list | None:
+        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(self._save_path, "autosave.json")
+        # else:
+        filename = Path(self._save_path) / self.state_name
+        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.state_name = self.load_value("savefile_name", "")
+        # 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 = Path(self._save_path) / "autosave.json"
+            self.save_value("savefile_name", self.state_name)
+            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:
+            if self.state_name == "autosave.json":
+                self.state_name = chose_filename(self._save_path)
+                self.save_value("savefile_name", self.state_name)
+            filename = Path(self._save_path) / self.state_name
+            self._state["savefile_name"] = self.state_name
+
+            # Auto save file will be removed after a successful save
+            try:
+                os.remove(Path(self._save_path) / "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 chose_filename(save_path: PathLike):
+
+    files = os.listdir(save_path)
+    game_idx = 0
+    while True:
+        savegame = f"{SAVE_FILE_NAME}_{game_idx:03d}.json"
+        if savegame not in files:
+            return savegame
+        game_idx += 1
+
+
+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):
+    os.makedirs(save_path, exist_ok=True)
+    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.json"] = GameState(save_path)
+        all_games["autosave.json"].load_from_disk(autosave=True)
+        LOG.debug(
+            "Loading saved game from autosave.json (%s)",
+            all_games["autosave.json"].state_name,
+        )
+
+    game_idx = 0
+    while True:
+        savegame = f"{save_file_name}_{game_idx:03d}.json"
+        if savegame in files:
+            all_games[savegame] = GameState(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/memory.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, List
+
+from ..types.player import Player
+
+if TYPE_CHECKING:
+    from ..objects.creature import Creature
+    from ..usables.item import Item
+    from .quest import Quest
+
+
+class Memory:
+    def __init__(self):
+        self.player: Dict[Player, Creature] = {}
+        self.items: Dict[str, Any] = {}
+        self.quests: List[Quest] = []
+        self.teleport_active: Dict[Player, bool] = {p: False for p in Player}
+        self.dialog_active: Dict[Player, bool] = {p: False for p in Player}
+        self.script_active: Dict[Player, bool] = {p: False for p in Player}
+        self.player_collision_active: Dict[Player, bool] = {
+            p: False for p in Player
+        }
+        self.bag: Dict[Player, List[Item]] = {p: [] for p in Player}
+        self.map_name: Dict[Player, str] = {}
+
+        self.last_spawn_px: Dict[Player, float] = {p: 0.0 for p in Player}
+        self.last_spawn_py: Dict[Player, float] = {p: 0.0 for p in Player}

mima/states/quest.py

@@ -0,0 +1,71 @@
+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
+    from ..types.player import Player
+
+
+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, target: Dynamic, nature: Nature, player: Player):
+        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,23 @@
+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
+    ICON = 13
+
+
+class Until(Enum):
+    UNLOCK = 0
+    NEXT_UPDATE = 1

mima/types/keys.py

@@ -0,0 +1,64 @@
+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
+    P1_UP = 12
+    P1_DOWN = 13
+    P1_LEFT = 14
+    P1_RIGHT = 15
+    P1_A = 16
+    P1_B = 17
+    P1_X = 18
+    P1_Y = 19
+    P1_R = 20
+    P1_L = 21
+    P1_START = 22
+    P1_SELECT = 23
+    P2_UP = 24
+    P2_DOWN = 25
+    P2_LEFT = 26
+    P2_RIGHT = 27
+    P2_A = 28
+    P2_B = 29
+    P2_X = 30
+    P2_Y = 31
+    P2_R = 32
+    P2_L = 33
+    P2_START = 34
+    P2_SELECT = 35
+    P3_UP = 36
+    P3_DOWN = 37
+    P3_LEFT = 38
+    P3_RIGHT = 39
+    P3_A = 40
+    P3_B = 41
+    P3_X = 42
+    P3_Y = 43
+    P3_R = 44
+    P3_L = 45
+    P3_START = 46
+    P3_SELECT = 47
+    P4_UP = 48
+    P4_DOWN = 49
+    P4_LEFT = 50
+    P4_RIGHT = 51
+    P4_A = 52
+    P4_B = 53
+    P4_X = 54
+    P4_Y = 55
+    P4_R = 56
+    P4_L = 57
+    P4_START = 58
+    P4_SELECT = 59

mima/types/mode.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class Mode(Enum):
+    LOADING = 0
+    MENU = 1
+    SESSION = 2
+    COMBAT = 3
+    INVENTORY = 4

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/player.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+
+class Player(Enum):
+    P0 = 0
+    P1 = 1
+    P2 = 2
+    P3 = 3
+    P4 = 4

mima/types/position.py

@@ -0,0 +1,13 @@
+from enum import Enum
+
+
+class Position:
+    BOTTOM = 0
+    BOTTOM_LEFT = 1
+    LEFT = 2
+    TOP_LEFT = 3
+    TOP = 4
+    TOP_RIGHT = 5
+    RIGHT = 6
+    BOTTOM_RIGHT = 7
+    CENTER = 8

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/tile_collision.py

@@ -0,0 +1,11 @@
+from enum import Enum
+
+
+class TileCollision(Enum):
+    TOP = 0
+    BOTTOM = 1
+    ANY = 2
+    TOP_2 = 3
+    TOP_3 = 4
+    BOTTOM_2 = 5
+    BOTTOM_3 = 6

mima/types/weapon_slot.py

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

mima/types/window.py

@@ -0,0 +1,44 @@
+from enum import Enum
+
+
+class Window(Enum):
+    PLACEHOLDER = -1
+    LOADING = 0
+    TITLE = 1
+    SELECT_GAME = 2
+    SETTINGS = 3
+    CONTROLS = 4
+    TOP_DOWN_MAP_1 = 5
+    TOP_DOWN_MAP_2 = 6
+    TOP_DOWN_MAP_3 = 7
+    SIDE_MAP_1 = 8
+    SIDE_MAP_2 = 9
+    SIDE_MAP_3 = 10
+    WORLD_MAP_1 = 11
+    WORLD_MAP_2 = 12
+    WORLD_MAP_3 = 13
+    INVENTORY_START = 14
+    INVENTORY_STATUS = 15
+    INVENTORY_ITEMS = 16
+    INVENTORY_EQUIPMENT = 17
+    INVENTORY_MAGIC = 18
+    INVENTORY_SKILLS = 19
+    INVENTORY_QUESTS = 20
+    INVENTORY_PROGRESS = 21
+    COMBAT = 22
+    TEAM_ACTION = 23
+    CHANGE_POSITION = 24
+    ESCAPCE = 25
+    CHARACTER_ACTION = 26
+    ITEM_SELECT = 27
+    MAGIC_SELECT = 28
+    SPECIAL_SELECT = 29
+    TARGET_SELECT = 30
+    OPPONENTS = 31
+    THEATRE = 32
+    VICTORY = 33
+    SHOP = 34
+    GAME_OVER = 35
+    CONTROLS_1 = 36
+    CONTROLS_2 = 37
+    CONTROLS_3 = 38