mini-arcade-core 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

mini_arcade_core/__init__.py

@@ -21,7 +21,10 @@ def run_game(initial_scene_cls: type[Scene], config: GameConfig | None = None):
     Convenience helper to bootstrap and run a game with a single scene.
 
     :param initial_scene_cls: The Scene subclass to instantiate as the initial scene.
+    :type initial_scene_cls: type[Scene]
+
     :param config: Optional GameConfig to customize game settings.
+    :type config: GameConfig | None
     """
     game = Game(config or GameConfig())
     scene = initial_scene_cls(game)

mini_arcade_core/backend.py

@@ -11,7 +11,14 @@ from typing import Iterable, Protocol
 
 
 class EventType(Enum):
-    """High-level event types understood by the core."""
+    """
+    High-level event types understood by the core.
+
+    :cvar UNKNOWN: Unknown/unhandled event.
+    :cvar QUIT: User requested to quit the game.
+    :cvar KEYDOWN: A key was pressed.
+    :cvar KEYUP: A key was released.
+    """
 
     UNKNOWN = auto()
     QUIT = auto()
@@ -46,20 +53,39 @@ class Backend(Protocol):
     def init(self, width: int, height: int, title: str) -> None:
         """
         Initialize the backend and open a window.
-
         Should be called once before the main loop.
+
+        :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: str
         """
 
     def poll_events(self) -> Iterable[Event]:
         """
         Return all pending events since last call.
-
         Concrete backends will translate their native events into core Event objects.
+
+        :return: An iterable of Event objects.
+        :rtype: Iterable[Event]
         """
 
     def set_clear_color(self, r: int, g: int, b: int) -> None:
         """
         Set the background/clear color used by begin_frame.
+
+        :param r: Red component (0-255).
+        :type r: int
+
+        :param g: Green component (0-255).
+        :type g: int
+
+        :param b: Blue component (0-255).
+        :type b: int
         """
 
     def begin_frame(self) -> None:
@@ -84,8 +110,22 @@ class Backend(Protocol):
     ) -> None:
         """
         Draw a filled rectangle in some default color.
-
         We'll keep this minimal for now; later we can extend with colors/sprites.
+
+        :param x: X position of the rectangle's top-left corner.
+        :type x: int
+
+        :param y: Y position of the rectangle's top-left corner.
+        :type y: int
+
+        :param w: Width of the rectangle.
+        :type w: int
+
+        :param h: Height of the rectangle.
+        :type h: int
+
+        :param color: RGB color tuple.
+        :type color: tuple[int, int, int]
         """
 
     # pylint: enable=too-many-arguments,too-many-positional-arguments
@@ -102,6 +142,18 @@ class Backend(Protocol):
 
         Backends may ignore advanced styling for now; this is just to render
         simple labels like menu items, scores, etc.
+
+        :param x: X position of the text's top-left corner.
+        :type x: int
+
+        :param y: Y position of the text's top-left corner.
+        :type y: int
+
+        :param text: The text string to draw.
+        :type text: str
+
+        :param color: RGB color tuple.
+        :type color: tuple[int, int, int]
         """
 
     def capture_frame(self, path: str | None = None) -> bytes | None:
@@ -109,5 +161,11 @@ class Backend(Protocol):
         Capture the current frame.
         If `path` is provided, save to that file (e.g. PNG).
         Returns raw bytes (PNG) or None if unsupported.
+
+        :param path: Optional file path to save the screenshot.
+        :type path: str | None
+
+        :return: Raw image bytes if no path given, else None.
+        :rtype: bytes | None
         """
         raise NotImplementedError

mini_arcade_core/game.py

@@ -7,9 +7,12 @@ from __future__ import annotations
 import os
 from dataclasses import dataclass
 from datetime import datetime
+from pathlib import Path
 from time import perf_counter, sleep
 from typing import TYPE_CHECKING
 
+from PIL import Image  # type: ignore[import]
+
 from .backend import Backend
 
 if TYPE_CHECKING:  # avoid runtime circular import
@@ -119,18 +122,50 @@ class Game:
         if self._current_scene is not None:
             self._current_scene.on_exit()
 
+    @staticmethod
+    def _convert_bmp_to_image(bmp_path: str, out_path: str) -> bool:
+        """
+        Convert a BMP file to another image format using Pillow.
+
+        :param bmp_path: Path to the input BMP file.
+        :type bmp_path: str
+
+        :param out_path: Path to the output image file.
+        :type out_path: str
+
+        :return: True if conversion was successful, False otherwise.
+        :rtype: bool
+        """
+        try:
+            img = Image.open(bmp_path)
+            img.save(out_path)  # Pillow chooses format from extension
+            return True
+        except Exception:
+            return False
+
     def screenshot(
         self, label: str | None = None, directory: str = "screenshots"
     ) -> str | None:
         """
         Ask backend to save a screenshot. Returns the file path or None.
+
+        :param label: Optional label to include in the filename.
+        :type label: str | None
+
+        :param directory: Directory to save screenshots in.
+        :type directory: str
+
+        :return: The file path of the saved screenshot, or None on failure.
+        :rtype: str | None
         """
         os.makedirs(directory, exist_ok=True)
         stamp = datetime.now().strftime("%Y%m%d_%H%M%S")
         label = label or "shot"
-        filename = f"{stamp}_{label}.png"
-        path = os.path.join(directory, filename)
+        filename = f"{stamp}_{label}"
+        bmp_path = os.path.join(directory, f"{filename}.bmp")
 
-        if self.backend.capture_frame(path):
-            return path
+        if self.backend.capture_frame(bmp_path):
+            out_path = Path(directory) / f"{filename}.png"
+            self._convert_bmp_to_image(bmp_path, str(out_path))
+            return str(out_path)
         return None

mini_arcade_core/scene.py

@@ -27,18 +27,35 @@ class Scene(ABC):
         self._overlays: List[OverlayFunc] = []
 
     def add_overlay(self, overlay: OverlayFunc) -> None:
-        """Register an overlay (drawn every frame, after entities)."""
+        """
+        Register an overlay (drawn every frame, after entities).
+
+        :param overlay: A callable that takes a Backend and draws on it.
+        :type overlay: OverlayFunc
+        """
         self._overlays.append(overlay)
 
     def remove_overlay(self, overlay: OverlayFunc) -> None:
+        """
+        Unregister a previously added overlay.
+
+        :param overlay: The overlay to remove.
+        :type overlay: OverlayFunc
+        """
         if overlay in self._overlays:
             self._overlays.remove(overlay)
 
     def clear_overlays(self) -> None:
+        """Clear all registered overlays."""
         self._overlays.clear()
 
     def draw_overlays(self, surface: Backend) -> None:
-        """Call all overlays. Scenes should call this at the end of draw()."""
+        """
+        Call all overlays. Scenes should call this at the end of draw().
+
+        :param surface: The backend surface to draw on.
+        :type surface: Backend
+        """
         for overlay in self._overlays:
             overlay(surface)
 
@@ -52,18 +69,27 @@ class Scene(ABC):
 
     @abstractmethod
     def handle_event(self, event: object):
-        """Handle input / events (e.g. pygame.Event)."""
+        """
+        Handle input / events (e.g. pygame.Event).
+
+        :param event: The event to handle.
+        :type event: object
+        """
 
     @abstractmethod
     def update(self, dt: float):
-        """Update game logic. ``dt`` is the delta time in seconds."""
+        """
+        Update game logic. ``dt`` is the delta time in seconds.
 
-    @abstractmethod
-    def draw(self, surface: object):
-        """Render to the main surface."""
+        :param dt: Time delta in seconds.
+        :type dt: float
+        """
 
+    @abstractmethod
     def draw(self, surface: object):
-        """Render to the main surface."""
+        """
+        Render to the main surface.
 
-    def draw(self, surface: object):
-        """Render to the main surface."""
+        :param surface: The backend surface to draw on.
+        :type surface: object
+        """

{mini_arcade_core-0.7.2.dist-info → mini_arcade_core-0.7.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-arcade-core
-Version: 0.7.2
+Version: 0.7.4
 Summary: Tiny scene-based game loop core for small arcade games.
 License: Copyright (c) 2025 Santiago Rincón
            
@@ -34,6 +34,7 @@ Provides-Extra: dev
 Requires-Dist: black (>=24.10,<25.0) ; extra == "dev"
 Requires-Dist: isort (>=5.13,<6.0) ; extra == "dev"
 Requires-Dist: mypy (>=1.5,<2.0) ; extra == "dev"
+Requires-Dist: pillow (<12)
 Requires-Dist: pylint (>=3.3,<4.0) ; extra == "dev"
 Requires-Dist: pytest (>=8.3,<9.0) ; extra == "dev"
 Requires-Dist: pytest-cov (>=6.0,<7.0) ; extra == "dev"

mini_arcade_core-0.7.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+mini_arcade_core/__init__.py,sha256=0gkloHYTV8FmEZbBLxNNy-eJge2y7pkQ_PCcrfeJ3uo,1831
+mini_arcade_core/backend.py,sha256=SvsHDO0Fq86buTqMkOCSAidx2E4QAJ6mLsSa9ZQXEqY,4514
+mini_arcade_core/entity.py,sha256=mAkedH0j14giBQFRpQjaym46uczbQDln6nbxy0WFAqU,1077
+mini_arcade_core/game.py,sha256=qfJ4UiAA2Mu-iAkj5SvxWxteGO9-s79IjlJk9ORHliw,5077
+mini_arcade_core/scene.py,sha256=QENcn2hWUF3Ja9pU8NK67NYmC8ptnjdpUkg1qsUEl60,2435
+mini_arcade_core-0.7.4.dist-info/METADATA,sha256=3-lnmTd16f89QKre5WegNgd8xQ2fR4MoY5ZrCB1A2n4,8324
+mini_arcade_core-0.7.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+mini_arcade_core-0.7.4.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
+mini_arcade_core-0.7.4.dist-info/RECORD,,

mini_arcade_core-0.7.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-mini_arcade_core/__init__.py,sha256=0PFa04KRSY3kT8YoD24zfFt92HYfrk6QrH8IlHbmeo4,1753
-mini_arcade_core/backend.py,sha256=DZUEO4zMlXIk3ctD9ZNqvgOo7n_ZKpC6x--hIede_YY,2946
-mini_arcade_core/entity.py,sha256=mAkedH0j14giBQFRpQjaym46uczbQDln6nbxy0WFAqU,1077
-mini_arcade_core/game.py,sha256=yRMy0IJVB_yuF9P_SKjcxJG0YVMs52khVFLomSUeVw8,3935
-mini_arcade_core/scene.py,sha256=i8lmcTZ1IPcM-NDwVvKrvjCMcFVq1aD5nacOvU0ZONU,1883
-mini_arcade_core-0.7.2.dist-info/METADATA,sha256=UNpZCJ0APedKmetmYqtENHGlSIgW2uDjsvr2eYxlidI,8296
-mini_arcade_core-0.7.2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-mini_arcade_core-0.7.2.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
-mini_arcade_core-0.7.2.dist-info/RECORD,,