mima-engine 0.1.4__py3-none-any.whl → 0.2.0__py3-none-any.whl

mima/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.4"
+__version__ = "0.2.0"

mima/backend/pygame_assets.py

@@ -12,6 +12,7 @@ from ..maps.tiled.tiled_template import TiledTemplate
 from ..maps.tiled.tiled_tileset import TiledTileset
 
 if TYPE_CHECKING:
+    from ..maps.tilemap import Tilemap
     from ..util import RuntimeConfig
 
 LOG = logging.getLogger(__name__)
@@ -111,9 +112,9 @@ class PygameAssets:
             name = os.path.split(snd)[1].split(".")[0]
             self._load_sound(name, snd)
 
-        for csv in self._assets_to_load.get("csv", []):
-            name = os.path.split(csv)[1].split(".")[0]
-            self._load_csv(name, csv)
+        for csvf in self._assets_to_load.get("csv", []):
+            name = os.path.split(csvf)[1].split(".")[0]
+            self._load_csv(name, csvf)
 
     def _load_csv(self, name, filename):
         if not os.path.isfile(filename):
@@ -220,9 +221,9 @@ class PygameAssets:
             return name
         try:
             self._maps[name] = TiledMap(name, filename)
-        except KeyError as err:
-            print(f"Failed to load map={name}")
-            raise err
+        except KeyError:
+            LOG.exception(f"Failed to load map={name}")
+            raise
 
         return name
 
@@ -282,19 +283,24 @@ class PygameAssets:
         if name is None:
             return None
         else:
-            if self.rtc.flags["use_color"]:
+            if self.rtc.flags.get("use_color", False):
                 name_color = f"{name}_color"
             else:
                 name_color = name
             return self._sprites.get(name_color, self._sprites[name])
 
+    def new_map(self, name, tilemap: Tilemap):
+        self._maps[name] = tilemap
+
     def new_sprite(self, name, surface: pygame.Surface):
         self._sprites[name] = surface
 
     def get_tileset(self, name):
         if name not in self._tilesets:
-            LOG.warning("Could not find tileset %s.", name)
-            return self._tilesets["simple_sheet"]
+            msg = f"Could not find tileset '{name}'."
+            raise ValueError(msg)
+            # LOG.warning("Could not find tileset %s.", name)
+            # return self._tilesets["simple_sheet"]
         return self._tilesets[name]
 
     def get_template(self, name):

mima/backend/pygame_audio.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import logging
 from typing import TYPE_CHECKING, List, Tuple
 
 import pygame
@@ -7,6 +8,8 @@ import pygame
 if TYPE_CHECKING:
     from .pygame_assets import PygameAssets
 
+LOG = logging.getLogger(__name__)
+
 
 class PygameAudio:
     def __init__(self, assets: PygameAssets):
@@ -45,8 +48,8 @@ class PygameAudio:
                 self._play_music(name)
                 self.current_track = name
                 self.is_playing = True
-            except Exception as err:
-                print(f"Could not load {name}: {err}")
+            except Exception:
+                LOG.exception(f"Could not load {name}.")
 
     def _play_music(self, name: str, repeat: int = -1):
         pygame.mixer.music.load(self.assets.get_music(name))

mima/backend/pygame_backend.py

@@ -1,30 +1,33 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Dict, List, Optional
 
 import pygame
 
 from ..types.blend import Blend
 from ..util.colors import BLACK, WHITE, Color
 from ..util.constants import (
-    BIG_FONT_HEIGHT,
     BIG_FONT_NAME,
-    BIG_FONT_WIDTH,
     SMALL_FONT_HEIGHT,
     SMALL_FONT_NAME,
     SMALL_FONT_WIDTH,
 )
 from .pygame_assets import PygameAssets
 from .pygame_audio import PygameAudio
+from .pygame_camera import PygameCamera
 from .pygame_events import SDL2_BACKGROUND_EVENTS, PygameUserInput
 
 if TYPE_CHECKING:
     from ..engine import MimaEngine
+    from ..types.keys import Key as K
+    from ..types.player import Player
     from ..util import RuntimeConfig
 
 LOG = logging.getLogger(__name__)
 
+C_DISPLAY = "display"
+
 
 class PygameBackend:
     engine: MimaEngine
@@ -57,14 +60,22 @@ class PygameBackend:
         self._filter_blend: Blend = Blend.DEFAULT
         self._last_sprite_name: str = ""
         self._last_sprite: pygame.Surface
+        self._cameras: Dict[str, PygameCamera] = {}
 
-    def init(self):
+    def init(
+        self,
+        keyboard_map: Optional[Dict[K, List[str]]] = None,
+        joystick_map: Optional[Dict[K, List[str]]] = None,
+        joy_to_player: Optional[Dict[int, Player]] = None,
+    ):
         LOG.info("Initializing pygame backend.")
         pygame.mixer.pre_init(44100, -16, 2, 2048)
         pygame.init()
 
         self.clock = pygame.time.Clock()
-        self.user_input = PygameUserInput(platform=self.platform)
+        self.user_input = PygameUserInput(
+            keyboard_map, joystick_map, joy_to_player, self.platform
+        )
         self.assets = PygameAssets(self.rtc, self.init_file)
         self.audio = PygameAudio(self.assets)
 
@@ -100,11 +111,14 @@ class PygameBackend:
 
         if pixel_size > 1:
             self.manual_scale = True
-            self.display = pygame.Surface(
-                (self.render_width, self.render_height)
-            )
+            self.new_camera(C_DISPLAY, self.render_width, self.render_height)
+            # self.display = pygame.Surface(
+            #     (self.render_width, self.render_height)
+            # )
         else:
-            self.display = self._screen
+            self.new_camera(C_DISPLAY, self.display_width, self.display_height)
+            self._cameras[C_DISPLAY].view = self._screen
+            # self.display = self._screen
 
         if self.platform == "PC":
             if self.icon_path:
@@ -121,26 +135,44 @@ class PygameBackend:
         self.user_input.width = self.render_width
         self.user_input.height = self.render_height
         self.assets.load()
-        # self.assets.load_items()
 
     def clear(self, color: Color = Color(0, 0, 0)):
-        self.display.fill(color.getRGBA())
-        self._filter = pygame.Surface((self.render_width, self.render_height))
-        self._filter.fill(self._filter_color.getRGBA())
+        for camera in self._cameras.values():
+            camera.clear(color)
+
+        if self.manual_scale:
+            self._screen.fill(color.getRGBA())
+
+    def add_camera(self, name, camera):
+        self._cameras[name] = camera
+
+    def remove_camera(self, name):
+        return self._cameras.pop(name)
+
+    def new_camera(self, name, width, height):
+        self._cameras[name] = PygameCamera(int(width), int(height))
+
+    def get_camera(self, name):
+        return self._cameras[name]
 
     def configure_filter(
-        self, color: Color = BLACK, blend_mode: Blend = Blend.DEFAULT
+        self,
+        color: Color = BLACK,
+        blend_mode: Blend = Blend.DEFAULT,
+        camera: str = C_DISPLAY,
     ):
-        self._filter_color = color
-        self._filter_blend = blend_mode
-
-    def apply_filter(self):
-        if self._filter_blend != Blend.DEFAULT:
-            self.display.blit(
-                self._filter,
-                pygame.Vector2(0, 0),
-                special_flags=blend_to_pygame_flag(self._filter_blend),
-            )
+        if camera == "all":
+            for cam in self._cameras.values():
+                cam.configure_filter(color, blend_mode)
+        else:
+            self._cameras[camera].configure_filter(color, blend_mode)
+
+    def apply_filter(self, camera: str = C_DISPLAY):
+        if camera == "all":
+            for cam in self._cameras.values():
+                cam.apply_filter()
+        else:
+            self._cameras[camera].apply_filter()
 
     def draw_partial_sprite(
         self,
@@ -151,14 +183,18 @@ class PygameBackend:
         sy: float,
         width: float,
         height: float,
+        camera_name: str = C_DISPLAY,
         blend_mode: Blend = Blend.DEFAULT,
         draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
     ):
         if sprite_name:
             if draw_to_filter:
-                display = self._filter
+                display = self._cameras[camera_name].filter
+            elif draw_to_ui:
+                display = self._cameras[camera_name].ui
             else:
-                display = self.display
+                display = self._cameras[camera_name].view
 
             if sprite_name != self._last_sprite_name:
                 self._last_sprite_name = sprite_name
@@ -171,22 +207,52 @@ class PygameBackend:
                         sprite,
                         pygame.Vector2(px, py),
                         pygame.Rect(sx, sy, width, height),
-                        special_flags=0
-                        if blend_mode == Blend.DEFAULT
-                        else blend_to_pygame_flag(blend_mode),
+                        special_flags=(
+                            0
+                            if blend_mode == Blend.DEFAULT
+                            else blend_to_pygame_flag(blend_mode)
+                        ),
                     )
-                except Exception as e:
-                    print(
-                        f"Exception drawing sprite {sprite_name}: {px}, {py}, {sx}, {sy}, {width}, {height}"
+                except Exception:
+                    LOG.exception(
+                        f"Exception drawing sprite {sprite_name}: {px}, "
+                        f"{py}, {sx}, {sy}, {width}, {height}"
                     )
-                    raise e
-        # else:
-        #     print(f"Draw sprite {sprite_name} at {(px, py)}.")
+                    raise
 
     def draw_line(
-        self, sx: float, sy: float, ex: float, ey: float, color: Color
+        self,
+        sx: float,
+        sy: float,
+        ex: float,
+        ey: float,
+        color: Color,
+        camera_name: str = C_DISPLAY,
+        blend_mode: Blend = Blend.DEFAULT,
+        draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
+        width: int = 1,
     ):
-        pygame.draw.line(self.display, color.getRGBA(), (sx, sy), (ex, ey))
+        if draw_to_filter:
+            display = self._cameras[camera_name].filter
+        elif draw_to_ui:
+            display = self._cameras[camera_name].ui
+        else:
+            display = self._cameras[camera_name].view
+        if blend_mode == Blend.DEFAULT:
+            pygame.draw.line(
+                display, color.getRGBA(), (sx, sy), (ex, ey), width
+            )
+        else:
+            surf = pygame.Surface(
+                (ex, ey)
+            )  # FIXME: lines into negative directions
+            surf.fill(BLACK)
+            pygame.draw.line(surf, color.getRGBA(), (0, 0), (ex, ey), width)
+            rect = surf.get_rect(topleft=(0, 0))
+            display.blit(
+                surf, rect, special_flags=blend_to_pygame_flag(blend_mode)
+            )
 
     def fill_circle(
         self,
@@ -194,13 +260,17 @@ class PygameBackend:
         py: float,
         radius: float,
         color: Color,
+        camera_name: str = C_DISPLAY,
         blend_mode: Blend = Blend.DEFAULT,
         draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
     ):
         if draw_to_filter:
-            display = self._filter
+            display = self._cameras[camera_name].filter
+        elif draw_to_ui:
+            display = self._cameras[camera_name].ui
         else:
-            display = self.display
+            display = self._cameras[camera_name].view
 
         if blend_mode == Blend.DEFAULT:
             pygame.draw.circle(display, color.getRGBA(), (px, py), radius)
@@ -215,10 +285,32 @@ class PygameBackend:
                 special_flags=blend_to_pygame_flag(blend_mode),
             )
 
-    def draw_circle(self, px: float, py: float, radius: float, color: Color):
-        pygame.draw.circle(
-            self.display, color.getRGBA(), (px, py), radius, width=1
-        )
+    def draw_circle(
+        self,
+        px: float,
+        py: float,
+        radius: float,
+        color: Color,
+        camera_name: str = C_DISPLAY,
+        blend_mode: Blend = Blend.DEFAULT,
+        draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
+    ):
+        if draw_to_filter:
+            display = self._cameras[camera_name].filter
+        elif draw_to_ui:
+            display = self._cameras[camera_name].ui
+        else:
+            display = self._cameras[camera_name].view
+
+        if blend_mode == Blend.DEFAULT:
+            pygame.draw.circle(
+                display, color.getRGBA(), (px, py), radius, width=1
+            )
+        else:
+            raise NotImplementedError(
+                "Draw circle is not implemented with blendmode"
+            )
 
     def fill_rect(
         self,
@@ -227,13 +319,18 @@ class PygameBackend:
         width: float,
         height: float,
         color: Color,
+        camera_name: str = C_DISPLAY,
+        blend_mode: Blend = Blend.DEFAULT,
         draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
     ):
         r, g, b, a = color.getRGBA()
         if draw_to_filter:
-            display = self._filter
+            display = self._cameras[camera_name].filter
+        elif draw_to_ui:
+            display = self._cameras[camera_name].ui
         else:
-            display = self.display
+            display = self._cameras[camera_name].view
 
         if a < 255:
             surf = pygame.Surface((width, height))
@@ -254,40 +351,75 @@ class PygameBackend:
         width: float,
         height: float,
         color: Color,
+        camera_name: str = C_DISPLAY,
         line_width: int = 1,
+        blend_mode: Blend = Blend.DEFAULT,
+        draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
     ):
+
+        if draw_to_filter:
+            display = self._cameras[camera_name].filter
+        elif draw_to_ui:
+            display = self._cameras[camera_name].ui
+        else:
+            display = self._cameras[camera_name].view
         line_width = max(1, line_width)
         pygame.draw.rect(
-            self.display,
+            display,
             color.getRGB(),
             pygame.Rect(px, py, width, height),
             width=line_width,
         )
 
     def draw_big_text(
-        self, text: str, px: float, py: float, color: Color = WHITE
+        self,
+        text: str,
+        px: float,
+        py: float,
+        color: Color = WHITE,
+        camera_name: str = C_DISPLAY,
+        blend_mode: Blend = Blend.DEFAULT,
+        draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
     ):
         self.draw_text(
             text,
             px,
             py,
-            BIG_FONT_NAME,
-            BIG_FONT_WIDTH,
-            BIG_FONT_HEIGHT,
+            self.rtc.big_font_name,
+            self.rtc.big_font_width,
+            self.rtc.big_font_height,
             color,
+            camera_name,
+            blend_mode,
+            draw_to_filter,
+            draw_to_ui,
         )
 
     def draw_small_text(
-        self, text: str, px: float, py: float, color: Color = WHITE
+        self,
+        text: str,
+        px: float,
+        py: float,
+        color: Color = WHITE,
+        camera_name: str = C_DISPLAY,
+        blend_mode: Blend = Blend.DEFAULT,
+        draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
     ):
         self.draw_text(
             text,
             px,
             py,
-            SMALL_FONT_NAME,
-            SMALL_FONT_WIDTH,
-            SMALL_FONT_HEIGHT,
+            self.rtc.small_font_name,
+            self.rtc.small_font_width,
+            self.rtc.small_font_height,
             color,
+            camera_name,
+            blend_mode,
+            draw_to_filter,
+            draw_to_ui,
         )
 
     def draw_text(
@@ -299,6 +431,10 @@ class PygameBackend:
         font_width: int,
         font_height: int,
         color: Color = WHITE,
+        camera_name: str = C_DISPLAY,
+        blend_mode: Blend = Blend.DEFAULT,
+        draw_to_filter: bool = False,
+        draw_to_ui: bool = False,
     ):
         if color != WHITE:
             old_sprite = self.assets.get_sprite(font_name)
@@ -321,12 +457,21 @@ class PygameBackend:
                 sy,
                 font_width,
                 font_height,
+                camera_name,
+                blend_mode,
+                draw_to_filter,
+                draw_to_ui,
             )
             idx += 1
 
     def draw_pixel(self, px: float, py: float, color: Color):
         self.display.set_at((int(px), int(py)), color.getRGB())
 
+    def draw_camera(self, name, px, py, scale):
+        self.display.blit(
+            pygame.transform.scale_by(self._cameras[name], scale), (px, py)
+        )
+
     def set_caption(self, text: str):
         pygame.display.set_caption(text)
 
@@ -350,13 +495,66 @@ class PygameBackend:
 
             self.user_input.process(event)
 
-    def update_display(self):
-        if self.manual_scale:
+    def update_display(self, *cameras):
+        scale = self.display_width / self.render_width
+        for cam_name in cameras:
+            cam = self._cameras[cam_name]
+            # target_width = int(
+            #     self._screen.get_width()
+            #     + cam.render_width / self._screen.get_width()
+            # )
+            # target_height = int(
+            #     self._screen.get_height()
+            #     + cam.render_height / self._screen.get_height()
+            # )
+            # self._screen.blit(
+            #     pygame.transform.scale_by(cam.view, scale),
+            #     (cam.px * scale, cam.py * scale),
+            # )
+            self._screen.blit(
+                pygame.transform.scale(
+                    cam.view,
+                    (cam.render_width * scale, cam.render_height * scale),
+                ),
+                (cam.px * scale, cam.py * scale),
+            )
+        for cam_name in cameras:
+            cam = self._cameras[cam_name]
+            self._screen.blit(
+                pygame.transform.scale(
+                    cam.ui,
+                    (cam.render_width * scale, cam.render_height * scale),
+                ),
+                (cam.px * scale, cam.py * scale),
+                special_flags=(pygame.BLEND_ALPHA_SDL2),
+            )
+            # print(
+            #     cam_name,
+            #     (cam.px, cam.py),
+            #     cam.view.get_size(),
+            #     scale,
+            #     # (target_width, target_height),
+            #     # cam.camera_scale,
+            #     # (
+            #     #     cam.view.get_width() * cam.camera_scale,
+            #     #     cam.view.get_height() * cam.camera_scale,
+            #     # ),
+            # )
+        if not cameras and self.manual_scale:
+            self._screen.blit(
+                pygame.transform.scale(
+                    self._cameras[C_DISPLAY].view,
+                    (self.display_width, self.display_height),
+                ),
+                (0, 0),
+            )
             self._screen.blit(
                 pygame.transform.scale(
-                    self.display, (self.display_width, self.display_height)
+                    self._cameras[C_DISPLAY].ui,
+                    (self.display_width, self.display_height),
                 ),
                 (0, 0),
+                special_flags=(pygame.BLEND_ALPHA_SDL2),
             )
 
         pygame.display.flip()

mima/backend/pygame_camera.py

@@ -0,0 +1,63 @@
+from typing import Optional
+
+import pygame
+
+from ..types.blend import Blend
+from ..util.colors import BLACK, WHITE, Color, ALPHA
+
+
+class PygameCamera:
+    def __init__(self, width: int, height: int):
+        self.px: int = 0
+        self.py: int = 0
+        self.render_width = width
+        self.render_height = height
+        self.view: pygame.Surface = pygame.Surface((width, height))
+        self.filter: pygame.Surface = pygame.Surface((width, height))
+        self.ui: pygame.Surface = pygame.Surface((width, height))
+        self._filter_color: Color = BLACK
+        self._filter_blend: Blend = Blend.DEFAULT
+        self._ui_color: Color = ALPHA
+        self.camera_scale: float = 1.0
+
+    def clear(self, color: Color = BLACK):
+        self.view.fill(color.getRGBA())
+        self.filter.fill(self._filter_color.getRGBA())
+        self.ui.fill(self._ui_color.getRGBA())
+        self.ui.set_colorkey(self._ui_color.getRGBA())
+
+    def configure_filter(
+        self, color: Color = BLACK, blend_mode: Blend = Blend.DEFAULT
+    ):
+        self._filter_color = color
+        self._filter_blend = blend_mode
+
+    def apply_filter(self):
+        if self._filter_blend != Blend.DEFAULT:
+            self.view.blit(
+                self.filter,
+                pygame.Vector2(0, 0),
+                special_flags=blend_to_pygame_flag(self._filter_blend),
+            )
+
+    def change_zoom(self, width, height):
+        self.view = pygame.Surface((width, height))
+        self.filter = pygame.Surface((width, height))
+
+    def change_ui_zoom(self, width, height):
+        self.ui = pygame.Surface((width, height), flags=pygame.SRCALPHA)
+        self.ui.convert_alpha()
+        self.ui.set_colorkey(ALPHA.getRGBA())
+
+
+def blend_to_pygame_flag(blend_mode: Blend):
+    if blend_mode == Blend.DEFAULT:
+        return 0
+    elif blend_mode == Blend.ADD:
+        return pygame.BLEND_RGBA_ADD
+    elif blend_mode == Blend.SUB:
+        return pygame.BLEND_RGBA_SUB
+    elif blend_mode == Blend.MULT:
+        return pygame.BLEND_RGBA_MULT
+    else:
+        return 0