mini-arcade-core 1.0.1__tar.gz → 1.0.2__tar.gz

{mini_arcade_core-1.0.1 → mini_arcade_core-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-arcade-core
-Version: 1.0.1
+Version: 1.0.2
 Summary: Tiny scene-based game loop core for small arcade games.
 License: Copyright (c) 2025 Santiago Rincón
            

{mini_arcade_core-1.0.1 → mini_arcade_core-1.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [project]
 name = "mini-arcade-core"
-version = "1.0.1"
+version = "1.0.2"
 description = "Tiny scene-based game loop core for small arcade games."
 authors = [
     { name = "Santiago Rincon", email = "rincores@gmail.com" },

{mini_arcade_core-1.0.1 → mini_arcade_core-1.0.2}/src/mini_arcade_core/engine/commands.py

@@ -7,6 +7,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, List, Optional, Protocol, TypeVar
 
+from mini_arcade_core.runtime.scene.scene_port import ScenePolicy
+
 if TYPE_CHECKING:
     from mini_arcade_core.runtime.services import RuntimeServices
 
@@ -167,3 +169,27 @@ class ChangeSceneCommand(Command):
         context: CommandContext,
     ):
         context.services.scenes.change(self.scene_id)
+
+
+@dataclass(frozen=True)
+class ToggleDebugOverlayCommand(Command):
+    """Toggle the debug overlay scene."""
+
+    DEBUG_OVERLAY_ID = "debug_overlay"
+
+    def execute(self, context: CommandContext) -> None:
+        scenes = context.services.scenes
+        if scenes.has_scene(self.DEBUG_OVERLAY_ID):
+            scenes.remove_scene(self.DEBUG_OVERLAY_ID)
+            return
+
+        scenes.push(
+            self.DEBUG_OVERLAY_ID,
+            as_overlay=True,
+            policy=ScenePolicy(
+                blocks_update=False,
+                blocks_input=False,
+                is_opaque=False,
+                receives_input=False,
+            ),
+        )

{mini_arcade_core-1.0.1 → mini_arcade_core-1.0.2}/src/mini_arcade_core/engine/game.py

@@ -10,10 +10,12 @@ from typing import Dict, Literal
 
 from mini_arcade_core.backend import Backend, WindowSettings
 from mini_arcade_core.backend.events import EventType
+from mini_arcade_core.backend.keys import Key
 from mini_arcade_core.engine.commands import (
     CommandContext,
     CommandQueue,
     QuitCommand,
+    ToggleDebugOverlayCommand,
 )
 from mini_arcade_core.engine.render.packet import RenderPacket
 from mini_arcade_core.engine.render.pipeline import RenderPipeline
@@ -248,6 +250,9 @@ class Game:
                     w, h = e.size
                     logger.debug(f"Window resized event: {w}x{h}")
                     self.services.window.on_window_resized(w, h)
+                # if F1 pressed, toggle debug overlay
+                if e.type == EventType.KEYDOWN and e.key == Key.F1:
+                    self.command_queue.push(ToggleDebugOverlayCommand())
             timer.mark("events_polled")
 
             input_frame = self.services.input.build(events, frame_index, dt)

{mini_arcade_core-1.0.1 → mini_arcade_core-1.0.2}/src/mini_arcade_core/runtime/scene/scene_adapter.py

@@ -94,4 +94,32 @@ class SceneAdapter(ScenePort):
 
     def input_entry(self):
         vis = self.visible_entries()
-        return vis[-1] if vis else None
+        if not vis:
+            return None
+
+        # If some scene blocks input, only scenes at/above it can receive.
+        start_idx = 0
+        for idx in range(len(vis) - 1, -1, -1):
+            if vis[idx].policy.blocks_input:
+                start_idx = idx
+                break
+
+        candidates = vis[start_idx:]
+
+        # Pick the top-most candidate that actually receives input.
+        for entry in reversed(candidates):
+            if entry.policy.receives_input:
+                return entry
+
+        return None
+
+    def has_scene(self, scene_id: str) -> bool:
+        return any(item.entry.scene_id == scene_id for item in self._stack)
+
+    def remove_scene(self, scene_id: str) -> None:
+        # remove first match from top (overlay is usually near top)
+        for i in range(len(self._stack) - 1, -1, -1):
+            if self._stack[i].entry.scene_id == scene_id:
+                item = self._stack.pop(i)
+                item.entry.scene.on_exit()
+                return

{mini_arcade_core-1.0.1 → mini_arcade_core-1.0.2}/src/mini_arcade_core/runtime/scene/scene_port.py

@@ -23,11 +23,13 @@ class ScenePolicy:
     blocks_update: if True, scenes below do not tick/update (pause modal)
     blocks_input:  if True, scenes below do not receive input
     is_opaque:     if True, scenes below are not rendered
+    receives_input: if True, scene can receive input
     """
 
     blocks_update: bool = False
     blocks_input: bool = False
     is_opaque: bool = False
+    receives_input: bool = True
 
 
 @dataclass(frozen=True)
@@ -147,3 +149,22 @@ class ScenePort:
         :return: The SceneEntry that receives input, or None if no scenes are active.
         :rtype: SceneEntry | None
         """
+
+    def has_scene(self, scene_id: str) -> bool:
+        """
+        Check if a scene with the given ID exists in the stack.
+
+        :param scene_id: Identifier of the scene to check.
+        :type scene_id: str
+
+        :return: True if the scene exists in the stack, False otherwise.
+        :rtype: bool
+        """
+
+    def remove_scene(self, scene_id: str) -> None:
+        """
+        Remove a scene with the given ID from the stack.
+
+        :param scene_id: Identifier of the scene to remove.
+        :type scene_id: str
+        """

mini_arcade_core-1.0.2/src/mini_arcade_core/scenes/debug_overlay.py

@@ -0,0 +1,67 @@
+"""
+Debug overlay scene that displays FPS, window size, and scene stack information.
+"""
+
+from __future__ import annotations
+
+from mini_arcade_core.engine.render.packet import RenderPacket
+from mini_arcade_core.runtime.context import RuntimeContext
+from mini_arcade_core.runtime.input_frame import InputFrame
+from mini_arcade_core.scenes.autoreg import register_scene
+from mini_arcade_core.sim.protocols import SimScene
+
+
+@register_scene("debug_overlay")
+class DebugOverlayScene(SimScene):
+    """
+    A debug overlay scene that displays FPS, window size, and scene stack information.
+    """
+
+    def __init__(self, ctx: RuntimeContext):
+        super().__init__(ctx)
+        self._accum = 0.0
+        self._frames = 0
+        self._fps = 0.0
+
+    def tick(self, input_frame: InputFrame, dt: float) -> RenderPacket:
+        self._accum += dt
+        self._frames += 1
+        if self._accum >= 0.5:
+            self._fps = self._frames / self._accum
+            self._accum = 0.0
+            self._frames = 0
+
+        services = (
+            self.context.services
+        )  # or ctx.services (depends on your scene base)
+        # Justification: type checker can't infer type here
+        # pylint: disable=assignment-from-no-return
+        vp = services.window.get_viewport()
+        stack = services.scenes.visible_entries()
+        # pylint: enable=assignment-from-no-return
+
+        lines = [
+            f"FPS: {self._fps:5.1f}",
+            f"dt:  {dt*1000.0:5.2f} ms",
+            f"virtual: {vp.virtual_w}x{vp.virtual_h}",
+            f"window:   {vp.window_w}x{vp.window_h}",
+            f"scale: {vp.scale:.3f}",
+            f"offset: ({vp.offset_x},{vp.offset_y})",
+            "stack:",
+        ]
+        for e in stack:
+            lines.append(f"  - {e.scene_id} overlay={e.is_overlay}")
+
+        def draw(backend):
+            # translucent background panel
+            backend.draw_rect(
+                8, 8, 360, 18 * (len(lines) + 1), color=(0, 0, 0, 0.65)
+            )
+            y = 14
+            for line in lines:
+                backend.draw_text(
+                    16, y, line, color=(255, 255, 255), font_size=14
+                )
+                y += 18
+
+        return RenderPacket(ops=[draw])

{mini_arcade_core-1.0.1 → mini_arcade_core-1.0.2}/src/mini_arcade_core/scenes/registry.py

@@ -93,22 +93,23 @@ class SceneRegistry:
         for scene_id, cls in catalog.items():
             self.register_cls(scene_id, cls)
 
-    def discover(self, package: str) -> "SceneRegistry":
+    def discover(self, *packages: str) -> "SceneRegistry":
         """
         Import all modules in a package so @scene decorators run.
 
-        :param package: The package name to scan for scene modules.
-        :type package: str
+        :param packages: The package names to scan for scene modules.
+        :type packages: str
 
         :return: The SceneRegistry instance (for chaining).
         :rtype: SceneRegistry
         """
-        pkg = importlib.import_module(package)
-        if not hasattr(pkg, "__path__"):
-            return self  # not a package
+        for package in packages:
+            pkg = importlib.import_module(package)
+            if not hasattr(pkg, "__path__"):
+                continue
 
-        for mod in pkgutil.walk_packages(pkg.__path__, pkg.__name__ + "."):
-            importlib.import_module(mod.name)
+            for mod in pkgutil.walk_packages(pkg.__path__, pkg.__name__ + "."):
+                importlib.import_module(mod.name)
 
         self.load_catalog(snapshot())
         return self