mini-arcade-native-backend 0.5.0__cp310-cp310-win_amd64.whl → 0.6.0__cp310-cp310-win_amd64.whl

mini_arcade_native_backend/__init__.py

@@ -6,6 +6,7 @@ from __future__ import annotations
 
 import os
 import sys
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional, Union
 
@@ -42,6 +43,7 @@ if sys.platform == "win32":
 # pylint: disable=import-error
 from mini_arcade_core.backend import (  # pyright: ignore[reportMissingImports]
     Backend,
+    WindowSettings,
 )
 from mini_arcade_core.backend.events import (  # pyright: ignore[reportMissingImports]
     Event,
@@ -79,23 +81,49 @@ _NATIVE_TO_CORE = {
 }
 
 
+@dataclass
+class BackendSettings:
+    """
+    Settings for the NativeBackend.
+
+    :ivar font_path (Optional[str]): Optional path to a TTF font file to load.
+    :ivar font_size (int): Font size in points to use when loading the font.
+    :ivar sounds (Optional[dict[str, str]]): Optional dictionary mapping sound IDs to file paths.
+    """
+
+    font_path: Optional[str] = None
+    font_size: int = 24
+    sounds: Optional[dict[str, str]] = None  # sound_id -> path
+
+
+# TODO: Refactor backend interface into smaller protocols?
+# Justification: Many public methods needed for backend interface
+# pylint: disable=too-many-public-methods,too-many-instance-attributes
 class NativeBackend(Backend):
     """Adapter that makes the C++ Engine usable as a mini-arcade backend."""
 
-    def __init__(self, font_path: str | None = None, font_size: int = 24):
+    def __init__(self, backend_settings: BackendSettings | None = None):
         """
-        :param font_path: Optional path to a TTF font file to load.
-        :type font_path: str | None
-
-        :param font_size: Font size in points to use when loading the font.
-        :type font_size: int
+        :param backend_settings: Optional settings for the backend.
+        :type backend_settings: BackendSettings | None
         """
         self._engine = native.Engine()
-        self._font_path = font_path
-        self._font_size = font_size
+
+        self._font_path = (
+            backend_settings.font_path if backend_settings else None
+        )
+        self._font_size = (
+            backend_settings.font_size if backend_settings else 24
+        )
         self._default_font_id: int | None = None
         self._fonts_by_size: dict[int, int] = {}
 
+        self._sounds = backend_settings.sounds if backend_settings else None
+
+        self._vp_offset_x = 0
+        self._vp_offset_y = 0
+        self._vp_scale = 1.0
+
     def _get_font_id(self, font_size: int | None) -> int:
         # No font loaded -> keep current “no-op” behavior
         if self._font_path is None:
@@ -122,22 +150,15 @@ class NativeBackend(Backend):
         self._fonts_by_size[font_size] = font_id
         return font_id
 
-    def init(self, width: int, height: int, title: Optional[str] = None):
+    def init(self, window_settings: WindowSettings):
         """
         Initialize the backend with a window of given width, height, and title.
 
-        :param width: Width of the window in pixels.
-        :type width: int
-
-        :param height: Height of the window in pixels.
-        :type height: int
-
-        :param title: Title of the window.
-        :type title: Optional[str]
+        :param window_settings: Settings for the backend window.
+        :type window_settings: WindowSettings
         """
-        if title is None:
-            title = ""
-        self._engine.init(width, height, title)
+        title = ""
+        self._engine.init(window_settings.width, window_settings.height, title)
 
         # Load font if provided
         if self._font_path is not None:
@@ -146,6 +167,11 @@ class NativeBackend(Backend):
             )
             self._fonts_by_size[self._font_size] = self._default_font_id
 
+        # Load sounds if provided
+        if self._sounds is not None:
+            for sound_id, path in self._sounds.items():
+                self.load_sound(sound_id, path)
+
     def set_window_title(self, title: str):
         """
         Set the window title.
@@ -273,12 +299,18 @@ class NativeBackend(Backend):
         if isinstance(alpha, bool):
             raise TypeError("alpha must be a float in [0,1], not bool")
 
-        a = float(alpha)
+        # If it's an int-like value, treat as 0..255
+        if isinstance(alpha, int):
+            if alpha < 0 or alpha > 255:
+                raise ValueError(
+                    f"int alpha must be in [0, 255], got {alpha!r}"
+                )
+            return int(alpha)
 
-        # Enforce “percentage only”
+        # Otherwise treat as float 0..1
+        a = float(alpha)
         if a < 0.0 or a > 1.0:
-            raise ValueError(f"alpha must be in [0, 1], got {alpha!r}")
-
+            raise ValueError(f"float alpha must be in [0, 1], got {alpha!r}")
         return int(round(a * 255))
 
     @staticmethod
@@ -328,7 +360,12 @@ class NativeBackend(Backend):
         :type color: tuple[int, ...]
         """
         r, g, b, a = self._get_color_values(color)
-        self._engine.draw_rect(x, y, w, h, r, g, b, a)
+        sx = int(round(self._vp_offset_x + x * self._vp_scale))  # top-left x
+        sy = int(round(self._vp_offset_y + y * self._vp_scale))  # top-left y
+        sw = int(round(w * self._vp_scale))  # width
+        sh = int(round(h * self._vp_scale))  # height
+        self._engine.draw_rect(sx, sy, sw, sh, r, g, b, a)
+        # self._engine.draw_rect(x, y, w, h, r, g, b, a)
 
     def draw_text(
         self,
@@ -356,9 +393,22 @@ class NativeBackend(Backend):
         """
         r, g, b, a = self._get_color_values(color)
         font_id = self._get_font_id(font_size)
+        sx = int(round(self._vp_offset_x + x * self._vp_scale))
+        sy = int(round(self._vp_offset_y + y * self._vp_scale))
+
+        # optional but recommended: scale font size too
+        if font_size is not None:
+            scaled = max(8, int(round(font_size * self._vp_scale)))
+        else:
+            scaled = None
+
+        font_id = self._get_font_id(scaled)
         self._engine.draw_text(
-            text, x, y, int(r), int(g), int(b), int(a), font_id
+            text, sx, sy, int(r), int(g), int(b), int(a), font_id
         )
+        # self._engine.draw_text(
+        #     text, x, y, int(r), int(g), int(b), int(a), font_id
+        # )
 
     # pylint: enable=too-many-arguments,too-many-positional-arguments
 
@@ -388,3 +438,97 @@ class NativeBackend(Backend):
         font_id = self._get_font_id(font_size)
         w, h = self._engine.measure_text(text, font_id)
         return int(w), int(h)
+
+    def init_audio(
+        self, frequency: int = 44100, channels: int = 2, chunk_size: int = 2048
+    ):
+        """Initialize SDL_mixer audio."""
+        self._engine.init_audio(int(frequency), int(channels), int(chunk_size))
+
+    def shutdown_audio(self):
+        """Shutdown SDL_mixer audio and free loaded sounds."""
+        self._engine.shutdown_audio()
+
+    def load_sound(self, sound_id: str, path: str):
+        """
+        Load a WAV sound and store it by ID.
+        Example: backend.load_sound("hit", "assets/sfx/hit.wav")
+        """
+        if not sound_id:
+            raise ValueError("sound_id cannot be empty")
+
+        p = Path(path)
+        if not p.exists():
+            raise FileNotFoundError(f"Sound file not found: {p}")
+
+        self._engine.load_sound(sound_id, str(p))
+
+    def play_sound(self, sound_id: str, loops: int = 0):
+        """
+        Play a loaded sound.
+        loops=0 => play once
+        loops=-1 => infinite loop
+        loops=1 => play twice (SDL convention)
+        """
+        self._engine.play_sound(sound_id, int(loops))
+
+    def set_master_volume(self, volume: int):
+        """
+        Master volume: 0..128
+        """
+        self._engine.set_master_volume(int(volume))
+
+    def set_sound_volume(self, sound_id: str, volume: int):
+        """
+        Per-sound volume: 0..128
+        """
+        self._engine.set_sound_volume(sound_id, int(volume))
+
+    def stop_all_sounds(self):
+        """Stop all channels."""
+        self._engine.stop_all_sounds()
+
+    def set_viewport_transform(
+        self, offset_x: int, offset_y: int, scale: float
+    ) -> None:
+        self._vp_offset_x = int(offset_x)
+        self._vp_offset_y = int(offset_y)
+        self._vp_scale = float(scale)
+
+    def clear_viewport_transform(self) -> None:
+        self._vp_offset_x = 0
+        self._vp_offset_y = 0
+        self._vp_scale = 1.0
+
+    def resize_window(self, width: int, height: int) -> None:
+        self._engine.resize_window(int(width), int(height))
+
+    def set_clip_rect(self, x: int, y: int, w: int, h: int) -> None:
+        self._engine.set_clip_rect(int(x), int(y), int(w), int(h))
+
+    def clear_clip_rect(self) -> None:
+        self._engine.clear_clip_rect()
+
+    # Justification: Many arguments needed for line drawing
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    def draw_line(
+        self,
+        x1: int,
+        y1: int,
+        x2: int,
+        y2: int,
+        color: tuple[int, ...] = (255, 255, 255),
+    ) -> None:
+        r, g, b, a = self._get_color_values(color)
+
+        sx1 = int(round(self._vp_offset_x + x1 * self._vp_scale))
+        sy1 = int(round(self._vp_offset_y + y1 * self._vp_scale))
+        sx2 = int(round(self._vp_offset_x + x2 * self._vp_scale))
+        sy2 = int(round(self._vp_offset_y + y2 * self._vp_scale))
+
+        self._engine.draw_line(
+            sx1, sy1, sx2, sy2, int(r), int(g), int(b), int(a)
+        )
+
+
+# pylint: enable=too-many-arguments,too-many-positional-arguments

{mini_arcade_native_backend-0.5.0.dist-info → mini_arcade_native_backend-0.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mini-arcade-native-backend
-Version: 0.5.0
+Version: 0.6.0
 Summary: Native SDL2 backend for mini-arcade-core using SDL2 + pybind11.
 Author-Email: Santiago Rincon <rincores@gmail.com>
 License: Copyright (c) 2025 Santiago Rincón
@@ -24,7 +24,7 @@ License: Copyright (c) 2025 Santiago Rincón
            SOFTWARE.
          
 Requires-Python: <3.12,>=3.9
-Requires-Dist: mini-arcade-core~=1.0
+Requires-Dist: mini-arcade-core~=1.1
 Provides-Extra: dev
 Requires-Dist: pytest~=8.3; extra == "dev"
 Requires-Dist: pytest-cov~=6.0; extra == "dev"

mini_arcade_native_backend-0.6.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+mini_arcade_native_backend/__init__.py,sha256=olqX3fkFRvLndg0rAeCPmpxM2EXd2-tLpVlkc2_gSIw,17911
+mini_arcade_native_backend/_native.cp310-win_amd64.pyd,sha256=Ut7acuvW5Vrg40sb12xH-N7Rt4ud5FuWMzocHMePQgk,228352
+mini_arcade_native_backend-0.6.0.dist-info/METADATA,sha256=7RyY7NLksROfXcHxhMHbq9bauVSvJAtnmVKdVU1T2eI,10517
+mini_arcade_native_backend-0.6.0.dist-info/WHEEL,sha256=hrGeChGtn46HBGmzasO9QQDSLelRN-tUarBSv4gFcsI,106
+mini_arcade_native_backend-0.6.0.dist-info/licenses/LICENSE,sha256=cZRgTdRJ3YASekMxkGAvylB2nROh4ov228DxAogK3yY,1115
+mini_arcade_native_backend-0.6.0.dist-info/RECORD,,

mini_arcade_native_backend-0.5.0.dist-info/RECORD

@@ -1,6 +0,0 @@
-mini_arcade_native_backend/__init__.py,sha256=CtzaxGTyVhLBVDB6naaqR0LCCz3CSuUpJP2SXQGCz64,12704
-mini_arcade_native_backend/_native.cp310-win_amd64.pyd,sha256=yNkXT_iRcmgq792R_JD1B56_e_6_i9vDJkmwRU8nQ9g,213504
-mini_arcade_native_backend-0.5.0.dist-info/METADATA,sha256=BrvJBIkrJ0pxAxOSm1yV9_Ga88JFpOMB6G7mUgRSaZY,10517
-mini_arcade_native_backend-0.5.0.dist-info/WHEEL,sha256=hrGeChGtn46HBGmzasO9QQDSLelRN-tUarBSv4gFcsI,106
-mini_arcade_native_backend-0.5.0.dist-info/licenses/LICENSE,sha256=cZRgTdRJ3YASekMxkGAvylB2nROh4ov228DxAogK3yY,1115
-mini_arcade_native_backend-0.5.0.dist-info/RECORD,,