mima-engine 0.4.0__py3-none-any.whl

mima/view/mima_scene.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+from ..types.position import Position
+from ..types.window import Window
+from ..util.colors import BLACK, WHITE
+from ..util.constants import (
+    DIALOG_CHARS_PER_LINE,
+    DIALOG_HEIGHT,
+    DIALOG_N_LINES,
+    DIALOG_WIDTH,
+)
+from .camera import Camera
+from .mima_view import MimaView
+from .mima_window import MimaWindow
+
+if TYPE_CHECKING:
+    from ..objects.dynamic import Dynamic
+    from ..types.player import Player
+
+
+class MimaScene(MimaView):
+    def __init__(
+        self,
+        player: Player,
+        position: Position,
+        camera_name: Optional[str] = None,
+    ) -> None:
+        self.window_stack: List[Window] = []
+        self.windows: Dict[Window, MimaWindow] = {}
+        self._current_window: Optional[MimaWindow] = None
+        self.stack_changed = False
+        self.skip_draw_ui = False
+
+        self.player: Player = player
+        self._position: Position = position
+
+        self._camera_name: str = (
+            camera_name if camera_name is not None else f"C_{player.name}"
+        )
+        self._controls_camera_name: str = f"{self._camera_name}_CONTROLS"
+
+        self.camera: Camera
+        self.controls_camera: Camera
+        self._dialog_px: float
+        self._dialog_py: float
+        self._dialog_width: float = DIALOG_WIDTH
+        self._dialog_height: float = DIALOG_HEIGHT
+        self._dialog_spacing: float = 3 / self.engine.rtc.tile_height
+
+        self._dialog_text_color = BLACK
+        self._dialog_bg_color = WHITE
+
+        self.update_scene_position(self._position)
+
+    def update_scene_position(self, position: Position) -> None:
+        width = self.engine.backend.render_width / self.engine.rtc.tile_width
+        height = (
+            self.engine.backend.render_height / self.engine.rtc.tile_height
+        )
+        # print(f"Starting camera setup: {width}, {height}, {position}")
+        if position in (
+            Position.LEFT,
+            Position.RIGHT,
+            Position.TOP_LEFT,
+            Position.TOP_RIGHT,
+            Position.BOTTOM_LEFT,
+            Position.BOTTOM_RIGHT,
+        ):
+            width /= 2
+            self._dialog_px = 1
+        else:
+            self._dialog_px = width / 2 - self._dialog_width / 2
+
+        if position in (
+            Position.TOP,
+            Position.BOTTOM,
+            Position.TOP_LEFT,
+            Position.TOP_RIGHT,
+            Position.BOTTOM_LEFT,
+            Position.BOTTOM_RIGHT,
+        ):
+            height /= 2
+            self._dialog_py = height - 4
+        else:
+            self._dialog_py = height - 4
+
+        self.camera = Camera(self._camera_name, width, height)
+        # self.controls_camera = Camera(
+        #     self._controls_camera_name, width, height
+        # )
+        if position == Position.CENTER:
+            # print(f"Camera setup finished: {width}, {height}")
+            return
+
+        if position in (
+            Position.RIGHT,
+            Position.BOTTOM_RIGHT,
+            Position.TOP_RIGHT,
+        ):
+            self.camera.px = self.engine.backend.render_width / 2
+            self.camera.border_left = True
+
+        if position in (
+            Position.BOTTOM,
+            Position.BOTTOM_LEFT,
+            Position.BOTTOM_RIGHT,
+        ):
+            self.camera.py = self.engine.backend.render_height / 2
+            self.camera.border_top = True
+
+        if position in (
+            Position.LEFT,
+            Position.TOP_LEFT,
+            Position.BOTTOM_LEFT,
+        ):
+            self.camera.border_right = True
+            self.camera.border_color = BLACK
+
+        if position in (Position.TOP, Position.TOP_LEFT, Position.TOP_RIGHT):
+            self.camera.border_bottom = True
+            self.camera.border_color = BLACK
+
+    def update(
+        self,
+        elapsed_time: float,
+        *,
+        target: Optional[Dynamic] = None,
+        map_width: int = 0,
+        map_height: int = 0,
+    ) -> bool:
+        self.update_window()
+
+        self.camera.update(target, map_width, map_height)
+        self.update_dialog_position()
+
+        # print(type(self._current_window))
+        return self._current_window.update(elapsed_time, self.camera)
+
+    def clear_stack(self, windows: Optional[List[Window]] = None):
+        self.stack_changed = True
+        if windows is not None:
+            self.window_stack = windows
+        else:
+            self.window_stack = []
+
+    def add_window(self, window: Window):
+        self.window_stack.append(window)
+        self.stack_changed = True
+
+    def pop_window(self):
+        self.stack_changed = True
+        return self.window_stack.pop()
+
+    def get_window(self) -> MimaWindow:
+        return self._current_window
+
+    def get_next_window_type(self) -> Window:
+        return self.window_stack[-1]
+
+    def get_previous_window_type(self) -> Window:
+        return self.window_stack[-2]
+
+    def handle_user_input(self):
+        if self._current_window is None:
+            self.update_window()
+        self._current_window.handle_user_input(self.player)
+
+    def draw_map_and_objects(
+        self, player, camera, tmap, dynamics, projectiles, effects
+    ) -> None:
+        self._current_window.draw_map_layers(tmap, [-1, 0])
+        self._current_window.draw_objects_y_sorted(
+            dynamics + projectiles, [-1, 0, 1, 2]
+        )
+
+        self._current_window.draw_effect_layers(effects, [0])
+
+        self._current_window.draw_map_layers(tmap, [1, 2])
+
+        self._current_window.draw_effect_layers(effects, [1, 2, 3, 4])
+
+    def draw_ui(self):
+        if self.skip_draw_ui:
+            self.skip_draw_ui = False
+            return
+        self._current_window.draw_ui()
+        self._current_window.draw_controls()
+
+    def draw_camera_border(self):
+        self.camera.draw_borders()
+
+    def load_window(self):
+        self._current_window.load(
+            self.engine.get_view().maps[self.player].name
+        )
+
+    def update_window(self):
+        old_window = self._current_window
+        self._current_window = self.windows[self.window_stack[-1]]
+        self._current_window.set_camera(self.camera)
+        self._current_window.set_player(self.player)
+
+        if self._current_window != old_window or self.stack_changed:
+            self.stack_changed = False
+            if old_window is not None:
+                old_window.on_exit_focus()
+
+            self._current_window.on_enter_focus()
+            self.skip_draw_ui = True
+
+    def update_dialog_position(self):
+        self._dialog_px = (
+            self.camera.visible_tiles_ex - self._dialog_width
+        ) / 2
+        self._dialog_py = (
+            self.camera.visible_tiles_ey - self._dialog_height - 1
+        )
+
+    def display_dialog(self, lines):
+        self._current_window.display_dialog(
+            lines,
+            int(self._dialog_px * self.engine.rtc.tile_width),
+            int(self._dialog_py * self.engine.rtc.tile_height),
+            int(self._dialog_width * self.engine.rtc.tile_width),
+            int(self._dialog_height * self.engine.rtc.tile_height),
+            int(self._dialog_spacing * self.engine.rtc.tile_height),
+            self._dialog_text_color,
+            self._dialog_bg_color,
+        )

mima/view/mima_view.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..engine import MimaEngine
+
+
+class MimaView:
+    """Base class for all view related classes."""
+
+    engine: MimaEngine

mima/view/mima_window.py

@@ -0,0 +1,244 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, List, Optional
+
+from ..types.direction import Direction
+from ..types.keys import Key as K
+from ..types.player import Player
+from ..types.window import Window
+from ..util.colors import TRANS_CYAN, TRANS_LIGHT_RED
+from ..util.constants import BIG_FONT_HEIGHT, BIG_FONT_WIDTH
+from ..util.functions import wrap_text
+from .mima_view import MimaView
+
+if TYPE_CHECKING:
+    from ..maps.tilemap import Tilemap
+    from ..objects.dynamic import Dynamic
+    from ..util.colors import Color
+    from .camera import Camera
+    from .mima_mode import MimaMode
+    from .mima_scene import MimaScene
+
+
+class MimaWindow(MimaView):
+    def __init__(
+        self,
+        mode: MimaMode,
+        scene: MimaScene,
+        wtype: Window = Window.PLACEHOLDER,
+    ) -> None:
+        self.mode = mode
+        self.scene = scene
+        self.wtype = wtype
+
+        self.p_obj: Optional[Dynamic] = None
+        self.camera: Optional[Camera] = None
+        self.dialog_to_show: List[str] = []
+        self.additional_data: Optional[Any] = None
+
+    def on_enter_focus(self):
+        pass
+
+    def on_exit_focus(self):
+        pass
+
+    def update(self, elapsed_time: float, camera: Camera) -> bool:
+        return True
+
+    def handle_user_input(self, player: Player) -> None:
+        self.p_obj.vx = self.p_obj.vy = 0
+
+        if self.engine.keys.key_held(K.UP, player):
+            self.p_obj.vy = -1
+            self.p_obj.facing_direction = Direction.NORTH
+        if self.engine.keys.key_held(K.DOWN, player):
+            self.p_obj.vy = 1
+            self.p_obj.facing_direction = Direction.SOUTH
+        if self.engine.keys.key_held(K.LEFT, player):
+            self.p_obj.vx = -1
+            self.p_obj.facing_direction = Direction.WEST
+        if self.engine.keys.key_held(K.RIGHT, player):
+            self.p_obj.vx = 1
+            self.p_obj.facing_direction = Direction.EAST
+
+    def draw_map_layers(self, tilemap: Tilemap, layers: List[int]) -> None:
+        for pos in layers:
+            tilemap.draw_self(
+                self.camera.ox,
+                self.camera.oy,
+                self.camera.visible_tiles_sx,
+                self.camera.visible_tiles_sy,
+                self.camera.visible_tiles_ex,
+                self.camera.visible_tiles_ey,
+                pos,
+                self.camera.name,
+            )
+
+    def draw_objects_y_sorted(
+        self, objects: List[Dynamic], layers: Optional[List[int]] = None
+    ) -> None:
+        layers = layers if layers is not None else list(range(-3, 3))
+
+        y_sorted = sorted(objects, key=lambda obj: obj.py)
+        for layer in layers:
+            for obj in y_sorted:
+                if self._check_draw_object(obj, layer):
+                    # print(
+                    #     obj.px,
+                    #     obj.py,
+                    #     obj.name,
+                    #     self._camera.name,
+                    #     self._camera.ox,
+                    #     self._camera.oy,
+                    # )
+                    obj.draw_self(
+                        self.camera.ox, self.camera.oy, self.camera.name
+                    )
+                    if self.engine.draw_dyn_ids:
+                        self.engine.backend.draw_small_text(
+                            f"{obj.dyn_id}",
+                            (obj.px - self.camera.ox)
+                            * self.engine.rtc.tile_width,
+                            (obj.py - self.camera.oy) * obj.sprite.height
+                            + obj.sprite.height,
+                            self.engine.rtc.color_red,
+                            self.camera.name,
+                        )
+
+    def draw_effect_layers(
+        self, effects: List[Dynamic], layers: List[int]
+    ) -> None:
+        for layer in layers:
+            for effect in effects:
+                if effect.layer == layer:
+                    effect.draw_self(
+                        self.camera.ox, self.camera.oy, self.camera.name
+                    )
+
+    def _check_draw_object(self, obj, layer) -> bool:
+        if obj.redundant or not obj.visible or obj.layer != layer:
+            return False
+
+        return self.check_draw_object(obj, layer)
+
+    def check_draw_object(self, obj, layer) -> bool:
+        """Custom check if object should be drawn."""
+        return True
+
+    def draw_ui(self) -> None:
+        pass
+
+    def draw_controls(self) -> None:
+        if not self.engine.show_touch_controls:
+            return
+
+        state = self.engine.keys.get_touch_state()
+        if not state:
+            return
+
+        data_move = state[K.UP]
+        if data_move["active"]:
+            radius = self.engine.rtc.tile_width
+            self.engine.backend.draw_circle(
+                int(data_move["rsx"] * self.camera.pwidth),
+                int(data_move["rsy"] * self.camera.pheight),
+                radius,
+                TRANS_LIGHT_RED,
+                self.camera.name,
+                draw_to_ui=True,
+            )
+            self.engine.backend.fill_circle(
+                int(data_move["rpx"] * self.camera.pwidth),
+                int(data_move["rpy"] * self.camera.pheight),
+                radius,
+                TRANS_LIGHT_RED,
+                self.camera.name,
+                draw_to_ui=True,
+            )
+
+        for idx in range(4, 12):
+            key = K(idx)
+            data = state.get(key, {})
+            if not data:
+                continue
+            # print(data_a)
+
+            ppx = int(data["rpx"] * self.camera.pwidth)
+            ppy = int(data["rpy"] * self.camera.pheight)
+            pwidth = int(data["rwidth"] * self.camera.pwidth)
+            pheight = int(data["rheight"] * self.camera.pheight)
+            if data["active"]:
+                self.engine.backend.fill_rect(
+                    ppx,
+                    ppy,
+                    pwidth,
+                    pheight,
+                    TRANS_LIGHT_RED,
+                    self.camera.name,
+                    draw_to_ui=True,
+                )
+            else:
+                self.engine.backend.draw_rect(
+                    ppx,
+                    ppy,
+                    pwidth,
+                    pheight,
+                    TRANS_LIGHT_RED,
+                    self.camera.name,
+                    draw_to_ui=True,
+                )
+                text = key.name
+                text_width = len(text) * BIG_FONT_WIDTH
+                self.engine.backend.draw_big_text(
+                    text,
+                    int(ppx + pwidth / 2 - text_width / 2),
+                    int(ppy + pheight / 2 - BIG_FONT_HEIGHT / 2),
+                    TRANS_LIGHT_RED,
+                    self.camera.name,
+                    draw_to_ui=True,
+                )
+
+        # self.engine.backend.fill_circle(
+        #     int(data_a["px"] * self.camera.pwidth),
+        #     int(data_a["py"] * self.camera.pheight),
+        #     int(data_a["width"] * self.camera.pwidth / 2),
+        #     color,
+        #     self.camera.name,
+        #     draw_to_ui=True,
+        # )
+
+    def set_camera(self, camera: Camera):
+        self.camera = camera
+
+    def set_player(self, player: Player):
+        self.p_obj = self.engine.get_player(player)
+
+    def display_dialog(
+        self,
+        lines: List[str],
+        ppx: int,
+        ppy: int,
+        pwidth: int,
+        pheight: int,
+        pspacing: int,
+        text_color: Color,
+        bg_color: Color,
+    ):
+        self.engine.backend.fill_rect(
+            ppx, ppy, pwidth, pheight, bg_color, self.camera.name
+        )
+        self.engine.backend.draw_rect(
+            ppx, ppy, pwidth, pheight, text_color, self.camera.name
+        )
+        # print(ppx, ppy, pwidth, pheight, lines)
+        for idx, line in enumerate(lines):
+            self.engine.backend.draw_big_text(
+                line,
+                ppx + 4,
+                ppy
+                + 4
+                + idx * pspacing
+                + idx * self.engine.rtc.big_font_height,
+                text_color,
+                self.camera.name,
+            )

mima_engine-0.4.0.dist-info/METADATA

@@ -0,0 +1,47 @@
+Metadata-Version: 2.4
+Name: mima-engine
+Version: 0.4.0
+Summary: A game engine based on pygame.
+Author-email: Stephan Balduin <stephan.balduin@mailbox.org>
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Provides-Extra: ce
+Requires-Dist: pygame-ce; extra == 'ce'
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: pygame-ce; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Provides-Extra: pygame
+Requires-Dist: pygame; extra == 'pygame'
+Description-Content-Type: text/markdown
+
+# Mima Engine
+
+A game engine based on pygame.
+
+## Design Philosophy
+
+**standalone**:
+- zero architectural assumptions
+- suitable for any pygame project
+- copy-paste friendly
+
+**layered**:
+- introduces preferred patterns
+- assumes common game-loop structures
+- flexible but guided usage
+
+**integrated**:
+- opinionated systems
+- assumes specific data flow and lifecycle
+- intended for projects that opt into this style
+
+| Module     | Internal Imports | Copy-Paste Safe | Intended Use       |
+| ---------- | ---------------- | --------------- | ------------------ |
+| standalone | none             | yes             | drop-in utilities  |
+| layered    | shallow          | usually         | enhanced helpers   |
+| integrated | deep             | no              | full library usage |
+
+