mima-engine 0.4.0__py3-none-any.whl

mima/core/engine.py

@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import logging
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+from ..backend.pygame_assets import PygameAssets
+from ..backend.pygame_audio import PygameAudio
+from ..backend.pygame_backend import PygameBackend
+from ..backend.pygame_events import PygameUserInput
+from ..maps.template import Template
+from ..maps.tilemap import Tilemap
+from ..objects.animated_sprite import AnimatedSprite
+from ..objects.creature import Creature
+from ..objects.dynamic import Dynamic
+from ..objects.loader import ObjectLoader
+from ..objects.sprite import Sprite
+from ..scripts import Command, ScriptProcessor
+from ..states.memory import Memory
+from ..states.quest import Quest
+from ..types.gate_color import GateColor
+from ..types.mode import Mode
+from ..types.player import Player
+from ..usables.item import Item
+from ..usables.weapon import Weapon
+from ..util import RuntimeConfig
+from ..util.logging import install_trace_logger
+from ..view.camera import Camera
+from ..view.mima_view import MimaView
+from .database import Database
+
+if TYPE_CHECKING:
+    from .states.game_state import GameState
+
+LOG = logging.getLogger(__name__)
+
+
+class MimaEngine(ABC):
+    def __init__(
+        self,
+        init_file: str,
+        config_path: str,
+        default_config: Dict[str, Any],
+        platform: str = "PC",
+        caption: str = "MimaEngine",
+    ):
+        self.rtc = RuntimeConfig(config_path, default_config)
+        install_trace_logger()
+
+        self.backend: PygameBackend = PygameBackend(
+            self.rtc, init_file, platform
+        )
+        self.db: Database
+        self._caption: str = caption
+        self.seconds_total: float = 0.0
+        self.app_fps: float = 0.0
+        self.game_fps: float = 0.0
+        self.elapsed_time: float = 0.00022
+        self._app_time: float = 0.0
+
+        self.enable_touch_controls: bool = False
+        self.show_touch_controls: bool = False
+
+        self.mode: Mode = Mode.LOADING
+        self.gate_color: GateColor = GateColor.RED
+        self.n_gate_colors = 2
+        self.script: ScriptProcessor = None
+        self.memory: Memory = Memory()
+        self.all_games: Dict[str, GameState] = {}
+        self.current_game: str = ""
+        self.cameras: List[str] = []
+
+    def construct(
+        self,
+        width: int,
+        height: int,
+        pixel_size: int,
+        fullscreen: bool = False,
+        target_fps: int = 60,
+        resizable: bool = False,
+        no_scaled_flag: bool = False,
+        kb_map=None,
+    ):
+        """Initialize backend and create a window."""
+        AnimatedSprite.engine = self
+        Camera.engine = self
+        Command.engine = self
+        Database.engine = self
+        Dynamic.engine = self
+        # GameMode.engine = self
+        Item.engine = self
+        PygameBackend.engine = self
+        ObjectLoader.engine = self
+        Quest.engine = self
+        # Scene.engine = self
+        ScriptProcessor.engine = self
+        Sprite.engine = self
+        Template.engine = self
+        Tilemap.engine = self
+        MimaView.engine = self
+
+        self.script = ScriptProcessor()
+        self.db = Database()
+        self.backend.init(
+            keyboard_map=self.rtc.get_keyboard_map(),
+            joystick_map=self.rtc.get_joystick_map(),
+            joy_to_player=self.rtc.get_joy_to_player(),
+        )
+        self.backend.construct(
+            width,
+            height,
+            pixel_size,
+            fullscreen,
+            target_fps,
+            resizable,
+            no_scaled_flag,
+        )
+        self.backend.user_input.enable_touch_controls = (
+            self.enable_touch_controls
+        )
+
+        return True
+
+    def start(self):
+        """Start the main loop"""
+        app_frames = 0
+        game_frames = 0
+        app_seconds = 0.0
+        game_seconds = 0.0
+        app_frames_total = 0
+        game_frames_total = 0
+        self.seconds_total = 0.0
+
+        if self.on_user_create():
+            while self.backend.keep_running():
+                self.backend.set_caption(
+                    f"{self._caption} ({self.game_fps:.2f}/"
+                    f"{self.app_fps:.2f} fps)"
+                )
+                self.backend.process_events()
+
+                if not self.backend.keep_running():
+                    break
+
+                self.cameras = ["display"]
+                if not self.on_user_update(self.elapsed_time):
+                    print("Error in on_user_update")
+                    break
+
+                self.backend.update_display(*self.cameras)
+
+                self._app_time = self.backend.tick()
+                self.elapsed_time = min(self._app_time, 1.0 / 30.0)
+
+                app_seconds += self._app_time
+                game_seconds += self.elapsed_time
+                app_frames += 1
+                game_frames += 1
+
+                if game_seconds >= 1.0:
+                    game_frames_total += game_frames
+                    self.game_fps = game_frames
+                    game_frames = 0
+                    game_seconds -= 1.0
+                if app_seconds >= 1.0:
+                    app_frames_total += app_frames
+                    self.seconds_total += app_seconds
+                    self.app_fps = app_frames
+                    app_frames = 0
+                    app_seconds -= 1.0
+
+            print(
+                f"App/Game Frames total: {app_frames_total}/"
+                f"{game_frames_total}"
+            )
+            print(f"Seconds total: {self.seconds_total:.3f}")
+            print(
+                "Average App/Game FPS: "
+                f"{app_frames_total/self.seconds_total:.3f}/"
+                f"{game_frames_total/self.seconds_total:.3f}"
+            )
+
+        self.backend.shutdown()
+
+    @abstractmethod
+    def on_user_update(self, elapsed_time: float) -> bool:
+        """Update."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    def on_user_create(self) -> bool:
+        raise NotImplementedError()
+
+    def on_user_terminate(self) -> bool:
+        self.backend.terminate = True
+        return True
+
+    @property
+    def assets(self) -> PygameAssets:
+        return self.backend.assets
+
+    @property
+    def audio(self) -> PygameAudio:
+        return self.backend.audio
+
+    @property
+    def keys(self) -> PygameUserInput:
+        return self.backend.user_input
+
+    def get_map(self, map_name: str):
+        return self.backend.assets.get_map(map_name)
+
+    def load_usable(self, item: Item, item_id) -> None:
+        LOG.debug("Loading usable %s.", item_id)
+        item.init(self.db.get_usable_data(item_id))
+        self.memory.items[item_id] = item
+
+    # def load_weapon(self, weapon: Weapon, weapon_id: str) -> None:
+    #     LOG.debug("Loading weapon %s.", weapon_id)
+    #     weapon.init(self.db.get_weapon_data(weapon_id))
+    #     self.memory.items[weapon_id] = weapon
+
+    # def load_item(self, item: Item, item_id: str) -> None:
+    #     LOG.debug("Loading item %s.", item_id)
+    #     item.init(self.db.get_item_data(item_id))
+    #     self.memory.items[item_id] = item
+
+    # def load_item(self, item: Item):
+    #     LOG.debug(f"Loading item  {item.name}.")
+    #     self.memory.items[item.name] = item
+
+    def get_item(self, item_id: str):
+        try:
+            return self.memory.items[item_id]
+        except KeyError:
+            LOG.exception(f"Item '{item_id}' is not defined!")
+            raise
+        except TypeError:
+            print(type(self.memory.items), item_id)
+            raise
+
+    def give_item(self, item: Union[str, Item], player: Player = Player.P1):
+        if isinstance(item, str):
+            item = self.get_item(item)
+        self.memory.bag[player].append(item)
+        # self.items.append(item)
+        return True
+
+    def take_item(self, item: Union[str, Item], player: Player = Player.P1):
+        if isinstance(item, str):
+            item = self.get_item(item)
+
+        if item in self.memory.bag[player]:
+            self.memory.bag[player].remove(item)
+            return True
+        return False
+
+    def has_item(self, item: Union[str, Item], player: Player = Player.P1):
+        if isinstance(item, str):
+            item = self.get_item(item)
+
+        return item in self.memory.bag[player]
+        # return False
+
+    def progress_quest(self, quest_name: str, new_state: int):
+        for quest in self.quests:
+            if quest.name == quest_name:
+                quest.state = new_state
+
+    def on_enter_background(self):
+        LOG.debug("About to enter background")
+
+    def on_entered_background(self):
+        LOG.debug("Entered background")
+
+    def on_enter_foreground(self):
+        LOG.debug("About to enter foreground")
+
+    def on_entered_foreground(self):
+        LOG.debug("Entered foreground")
+
+    def get_player(self, player: Player = Player.P1):
+        if player in self.memory.player:
+            return self.memory.player[player]
+        else:
+            return None
+
+    def set_player(self, creature: Creature, player: Player = Player.P1):
+        self.memory.player[player] = creature
+
+    def trigger_teleport(
+        self, active: bool = True, player: Player = Player.P1
+    ):
+        self.memory.teleport_active[player] = active
+
+    def is_teleport_active(self, player: Player = Player.P1):
+        return self.memory.teleport_active[player]
+
+    def trigger_dialog(self, active: bool = True, player=Player.P1):
+        self.memory.dialog_active[player] = active
+
+    def is_dialog_active(self, player: Player = Player.P1):
+        return self.memory.dialog_active[player]
+
+    def trigger_script(
+        self, active: bool = True, player: Player = Player.P1
+    ) -> None:
+        self.memory.script_active[player] = active
+
+    def is_script_active(self, player: Player = Player.P1) -> bool:
+        return self.memory.script_active[player]
+
+    def trigger_player_collision(
+        self, active: bool = True, player: Player = Player.P1
+    ) -> None:
+        self.memory.player_collision_active[player] = active
+
+    def is_player_collision_active(self, player: Player = Player.P1) -> bool:
+        return self.memory.player_collision_active[player]
+
+    @property
+    def player(self):
+        print("Deprecated access to player. Use 'get_player' instead!")
+        return self.memory.player
+
+    @player.setter
+    def player(self, val):
+        print("Deprecated access to player. Use 'get_player' instead!")
+        self.memory.player = val
+
+    @property
+    def items(self):
+        # raise TypeError()
+        return self.memory.items
+
+    @items.setter
+    def items(self, val):
+        raise TypeError(f"Items cannot be set to type {type(val)}")
+        # self.memory.items = val
+
+    @property
+    def quests(self):
+        return self.memory.quests
+
+    @quests.setter
+    def quests(self, val):
+        self.memory.quests = val
+
+    @property
+    def dialog_active(self):
+        print("dialog_active is deprecated; use 'is_dialog_active()' instead.")
+        return self.memory.dialog_active
+
+    @dialog_active.setter
+    def dialog_active(self, val):
+        print(
+            "dialog_active is deprecated; use "
+            "'trigger_dialog(active)' instead."
+        )
+        self.memory.dialog_active = val
+
+    @property
+    def game_state(self) -> GameState:
+        return self.all_games[self.current_game]
+
+    def get_view(self):
+        return None

mima/core/mode_engine.py

@@ -0,0 +1,81 @@
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+from ..states.game_state import GameState
+from ..types.keys import Key as K
+from ..types.mode import Mode
+from ..types.nature import Nature
+from ..types.player import Player
+from ..view.mima_mode import MimaMode
+from .engine import MimaEngine
+
+# from .view.mima_scene import MimaScene
+LOG = logging.getLogger(__name__)
+
+
+class MimaModeEngine(MimaEngine):
+    def __init__(
+        self,
+        init_file: str,
+        config_path: str,
+        default_config: Dict[str, Any],
+        platform="PC",
+        caption: str = "MimaEngine",
+    ):
+        super().__init__(
+            init_file, config_path, default_config, platform, caption
+        )
+
+        self.modes: Dict[Mode, MimaMode] = {}
+        self.mode: Optional[MimaMode] = None
+
+        self.mode_stack: List[Mode] = []
+
+        self.draw_chunks: bool = False
+        self.draw_chunk_info: bool = False
+        self.draw_dyn_ids: bool = False
+        self.disable_filter: bool = False
+        self._timer = 1.0
+
+    def on_user_create(self):
+        # change_mode(Mode.LOADING)
+        # TODO add example modes
+        return True
+
+    def on_user_update(self, elapsed_time: float):
+        self.audio.update(elapsed_time)
+
+        # print("Update start")
+
+        if not self.mode.update(elapsed_time):
+            LOG.critical(f"Update of mode {self.mode} failed.")
+            return False
+        self._timer -= elapsed_time
+        if self._timer <= 0.0:
+            self._timer += 1.0
+            LOG.debug(
+                f"Updated {self.mode} (Current Stack:"
+                f"{[m.name for m in self.mode_stack]})"
+            )
+        # print("Update end")
+        return True
+
+    def change_mode(self, mode: Mode):
+        if mode in self.mode_stack:
+            self.mode_stack.remove(mode)
+        self.mode_stack.append(mode)
+        if self.mode is not None:
+            self.mode.unload()
+        self.mode = self.modes[mode]
+        self.mode.load()
+
+    def return_mode(self):
+        LOG.debug(
+            "Returning to previous mode. Stack: %s", str(self.mode_stack)
+        )
+        self.mode_stack.pop()
+        self.mode = self.modes[self.mode_stack[-1]]
+        self.mode.load()
+
+    def get_view(self):
+        return self.mode

mima/core/scene_engine.py

@@ -0,0 +1,81 @@
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+from .engine import MimaEngine
+from .states.game_state import GameState
+from .types.keys import Key as K
+from .types.mode import Mode
+from .types.nature import Nature
+from .types.player import Player
+from .view.scene import Scene
+
+
+class MimaSceneEngine(MimaEngine):
+    def __init__(
+        self,
+        init_file: str,
+        config_path: str,
+        default_config: Dict[str, Any],
+        platform: str = "PC",
+        caption: str = "MimaEngine",
+    ):
+        super().__init__(init_file, config_path, default_config, platform, caption)
+
+        self.scene_stack: List[str] = []
+        self._scenes: Dict[str, Scene] = {}
+        self._current_scene: Scene
+
+        self.save_timer_reset = 1.0
+        self._save_timer = self.save_timer_reset
+        # self.teleport_triggered: bool = False
+        # self.dialog_active: bool = False
+
+    def on_user_create(self):
+        return True
+
+    def on_user_update(self, elapsed_time: float):
+        self.audio.update(elapsed_time)
+        self._current_scene = self._scenes[self.scene_stack[-1]]
+
+        # self._current_scene = self.mode.name.lower()
+
+        self._save_timer -= elapsed_time
+        if self._save_timer <= 0.0:
+            self._save_timer += self.save_timer_reset
+            if self._current_scene.autosave:
+                for quest in self.quests:
+                    for obj in self.scene.dynamics:
+                        quest.on_interaction(self.scene.dynamics, obj, Nature.SAVE)
+                    quest.save_state()
+        if self.keys.new_key_press(K.SELECT):
+            self.game_state.save_to_disk()
+
+        self.scene.update(elapsed_time)
+
+        return True
+
+    def load_scene(self):
+        self.scene_stack
+
+    # def load_scene(self, map_name: str, px: float, py: float):
+    #     type_string = (
+    #         self.get_map(map_name).get_string("type", "local").upper()
+    #     )
+    #     if type_string == "WORLD":
+    #         type_string = "WORLD_MAP"
+    #     if type_string == "LOCAL":
+    #         type_string = "LOCAL_MAP"
+    #     mode = Mode[type_string]
+
+    #     self.scene_stack.append(mode)
+    #     self._scenes[self.scene_stack[-1]].load_scene()
+    #     # self._scenes[self.scene_stack[-1]].change_map(map_name, px, py)
+    #     # print(self.scene_stack)
+
+    @property
+    def scene(self) -> Scene:
+        # return self._scenes[self._current_scene]
+        return self._current_scene
+
+    @property
+    def previous_scene(self) -> Scene:
+        return self._scenes[self.scene_stack[-2]]

mima/integrated/entity.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from pygame import Vector2
+from typing_extensions import Any, Generic, TypeVar
+
+from mima.integrated.sprite import Direction, GraphicState, Until, vel_to_dir
+from mima.layered.shape import ShapeCollection
+from mima.layered.shaped_sprite import SpriteWithShape
+from mima.standalone.geometry import Circle, Rect
+from mima.standalone.transformed_view import TileTransformedView
+
+
+class Nature(Enum):
+    WALK = 0
+    ENTER = 1
+    EXIT = 2
+    TALK = 3
+    ATTACK = 4
+    KILLED = 5
+    SIGNAL = 6
+    NO_SIGNAL = 7
+    SAVE = 8
+    LOAD = 9
+    RESUME = 10
+
+
+TEntity = TypeVar("TEntity", bound="Entity")
+
+
+class Entity(Generic[TEntity]):
+    def __init__(
+        self,
+        pos: Vector2,
+        name: str,
+        sprite: SpriteWithShape[GraphicState, Direction],
+        dyn_id: int = -1,
+    ) -> None:
+        self._pos = pos
+        self.old_pos = Vector2(pos)
+        self.elevation: float = 0.0
+        self.name = name
+        self.sprite = sprite
+        self.dyn_id = dyn_id
+        self._facing_direction = Direction.SOUTH
+        self._graphic_state = GraphicState.STANDING
+
+        self._graphic_state_locked: bool = False
+        self._gs_lock_condition: Until = Until.UNLOCK
+
+        self.is_player: bool = False
+        self.is_collider: bool = False
+        self.collides_with_map: bool = False
+        self.collides_with_dyn: bool = False
+        self.is_redundant: bool = False
+
+        self._despawn_timer: float = 0.0
+        self.vel = Vector2(0, 0)
+
+        if self.sprite.hitbox is None:
+            self._hitbox: ShapeCollection = ShapeCollection(
+                pos, Circle(Vector2(0.5, 0.5), 0.5)
+            )
+        else:
+            self._hitbox = self.sprite.hitbox
+            self._hitbox.update(pos)
+
+        self.speed: float = 5.0
+
+        # Debug flags
+        self.draw_shapes: bool = False
+
+    def update(self, elapsed_time: float) -> bool:
+        return False
+
+    def update_visible(self, elapsed_time: float, ttv: TileTransformedView) -> bool:
+        return False
+
+    def update_global(self, elapsed_time: float) -> bool:
+        self.update_despawn_timer(elapsed_time)
+
+        new_direction = vel_to_dir(self.vel)
+        if new_direction is not None:
+            self._facing_direction = new_direction
+
+        if self.vel.x == 0 and self.vel.y == 0:
+            self._graphic_state = GraphicState.STANDING
+        else:
+            self._graphic_state = GraphicState.WALKING
+        if self.sprite.update(
+            elapsed_time, self._graphic_state, self._facing_direction
+        ):
+            self._hitbox = (
+                self.sprite.hitbox if self.sprite.hitbox is not None else self._hitbox
+            )
+            self._hitbox.update(self._pos)
+
+        return self.update(elapsed_time)
+
+    def update_despawn_timer(self, elapsed_time: float) -> bool:
+        if self._despawn_timer > 0:
+            self._despawn_timer -= elapsed_time
+            if self._despawn_timer <= 0.0:
+                self.is_redundant = True
+                return True
+        return False
+
+    def draw(self, ttv: TileTransformedView, cache: bool = False) -> None:
+        self.sprite.draw(self.get_pos(), ttv, cache=cache)
+
+        if self.draw_shapes:
+            ttv.draw_rect(
+                self._hitbox.bounding_box.pos,
+                self._hitbox.bounding_box.size,
+                (255, 0, 0),
+            )
+            for i, hb in enumerate(self._hitbox.shapes):
+                if isinstance(hb, Circle):
+                    ttv.draw_circle(hb.pos, hb.radius, (255 - 50 * (i + 1), 0, 0))
+                if isinstance(hb, Rect):
+                    ttv.draw_rect(hb.pos, hb.size, (255 - 50 * (i + 1), 0, 0))
+
+            ttv.fill_circle(self.get_pos(), 2 / 16, (0, 0, 0))
+            ttv.fill_circle(self.get_pos(), 1 / 16, (255, 255, 255))
+            ttv.fill_circle(self._hitbox.get_tl_pos(), 1 / 16, (0, 255, 255))
+            ttv.fill_circle(self._hitbox.get_br_pos(), 1 / 16, (255, 0, 255))
+
+    def on_interaction(self, obj: TEntity, nature: Nature) -> bool:
+        return False
+
+    def on_death(self) -> None:
+        return
+
+    def get_pos(self) -> Vector2:
+        return self._hitbox.pos
+
+    def set_pos(self, pos: Vector2) -> None:
+        self._pos = pos
+        self._hitbox.update(pos)
+
+    def get_hitbox(self) -> ShapeCollection:
+        return self._hitbox
+
+    def set_facing_direction(self, direction: Direction) -> None:
+        self._facing_direction = direction
+
+    def get_facing_direction(self) -> Direction:
+        return self._facing_direction
+
+    def set_graphic_state(self, graphic_state: GraphicState) -> bool:
+        if not self._graphic_state_locked:
+            self._graphic_state = graphic_state
+            return True
+        return False
+
+    def get_graphic_state(self) -> GraphicState:
+        return self._graphic_state
+
+    def lock_graphic_state(
+        self, graphic_state: GraphicState, until: Until = Until.UNLOCK
+    ) -> None:
+        self.set_graphic_state(graphic_state)
+        self._graphic_state_locked = True
+        self._gs_lock_condition = until
+
+    def unlock_graphic_state(self) -> None:
+        self._graphic_state_locked = False
+        self.set_graphic_state(GraphicState.STANDING)
+
+    def kill(self, delay: float = 0.0) -> None:
+        self._despawn_timer = delay
+        if self._despawn_timer <= 0.0:
+            self.is_redundant = True
+
+    def __str__(self) -> str:
+        return (
+            f"{self.__class__.__name__}(name={self.name}, id={self.dyn_id}, "
+            f"pos={self._hitbox.pos})"
+        )
+
+    def __repr__(self) -> str:
+        return str(self)