mini-arcade-core 1.1.1__py3-none-any.whl → 1.2.1__py3-none-any.whl

mini_arcade_core/runtime/scene/scene_query_adapter.py

@@ -0,0 +1,31 @@
+"""
+Scene query adapter implementation.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Sequence
+
+from mini_arcade_core.engine.scenes.models import SceneEntry
+from mini_arcade_core.engine.scenes.scene_manager import SceneAdapter
+from mini_arcade_core.runtime.scene.scene_query_port import SceneQueryPort
+
+
+@dataclass
+class SceneQueryAdapter(SceneQueryPort):
+    """Adapter that exposes a read-only view of the SceneAdapter manager."""
+
+    _scenes: SceneAdapter
+
+    def visible_entries(self) -> Sequence[SceneEntry]:
+        return list(self._scenes.visible_entries())
+
+    def input_entry(self) -> SceneEntry | None:
+        return self._scenes.input_entry()
+
+    def stack_summary(self) -> list[str]:
+        out: list[str] = []
+        for e in self._scenes.visible_entries():
+            out.append(f"{e.scene_id} overlay={e.is_overlay}")
+        return out

mini_arcade_core/runtime/scene/scene_query_port.py

@@ -0,0 +1,38 @@
+"""
+Scene query port protocol.
+"""
+
+from __future__ import annotations
+
+from typing import Protocol, Sequence, runtime_checkable
+
+from mini_arcade_core.engine.scenes.models import SceneEntry
+
+
+@runtime_checkable
+class SceneQueryPort(Protocol):
+    """Read-only queries over the engine scene stack."""
+
+    def visible_entries(self) -> Sequence[SceneEntry]:
+        """
+        Scenes that should be rendered (policy-aware).
+
+        :return: Sequence of SceneEntry instances that are visible.
+        :rtype: Sequence[SceneEntry]
+        """
+
+    def input_entry(self) -> SceneEntry | None:
+        """
+        The scene that currently receives input (top-most eligible).
+
+        :return: SceneEntry that receives input, or None if stack is empty.
+        :rtype: SceneEntry | None
+        """
+
+    def stack_summary(self) -> list[str]:
+        """
+        Convenience: human-readable stack lines for debug overlays.
+
+        :return: List of strings summarizing the scene stack.
+        :rtype: list[str]
+        """

mini_arcade_core/runtime/services.py

@@ -11,7 +11,7 @@ from mini_arcade_core.runtime.capture.capture_port import CapturePort
 from mini_arcade_core.runtime.file.file_port import FilePort
 from mini_arcade_core.runtime.input.input_port import InputPort
 from mini_arcade_core.runtime.render.render_port import RenderServicePort
-from mini_arcade_core.runtime.scene.scene_port import ScenePort
+from mini_arcade_core.runtime.scene.scene_query_port import SceneQueryPort
 from mini_arcade_core.runtime.window.window_port import WindowPort
 
 
@@ -26,12 +26,13 @@ class RuntimeServices:
     :ivar files (FilePort): File service port.
     :ivar capture (CapturePort): Capture service port.
     :ivar input (InputPort): Input handling service port.
+    :ivar render (RenderServicePort): Rendering service port.
     """
 
     window: WindowPort
-    scenes: ScenePort
     audio: AudioPort
     files: FilePort
     capture: CapturePort
     input: InputPort
     render: RenderServicePort
+    scenes: SceneQueryPort

mini_arcade_core/runtime/window/window_adapter.py

@@ -4,14 +4,14 @@ Module providing runtime adapters for window and scene management.
 
 from __future__ import annotations
 
-from venv import logger
-
+from mini_arcade_core.backend import Backend
 from mini_arcade_core.engine.render.viewport import (
     Viewport,
     ViewportMode,
     ViewportState,
 )
 from mini_arcade_core.runtime.window.window_port import WindowPort
+from mini_arcade_core.utils import logger
 
 
 class WindowAdapter(WindowPort):
@@ -19,71 +19,73 @@ class WindowAdapter(WindowPort):
     Manages multiple game windows (not implemented).
     """
 
-    def __init__(self, backend, window_settings):
-        self.backend = backend
-        self.window_settings = window_settings
-
-        self._initialized = False
+    _drawable_size: tuple[int, int]
 
-        # Default: virtual resolution == initial window resolution.
-        # You can override via set_virtual_resolution().
-        self._viewport = Viewport(
-            window_settings.width,
-            window_settings.height,
-            mode=ViewportMode.FIT,
-        )
-
-        # Cached current window size
-        self.size = (window_settings.width, window_settings.height)
+    def __init__(self, backend: Backend):
+        self.backend = backend
 
-    def set_window_size(self, width, height):
-        width = int(width)
-        height = int(height)
-        self.size = (width, height)
+        self.backend.init()
 
-        self.window_settings.width = width
-        self.window_settings.height = height
+        w, h = self.backend.window.size()
+        self.size = (w, h)
+        self._initialized = True
 
-        if not self._initialized:
-            self.backend.init(self.window_settings)
-            self._initialized = True
-        else:
-            self.backend.resize_window(width, height)
+        self._viewport = Viewport(w, h, mode=ViewportMode.FIT)
+        self._viewport.resize(w, h)
+        self._apply_viewport_transform()
 
-        self._viewport.resize(width, height)
+    def _apply_viewport_transform(self):
+        s = self._viewport.state
+        # This is the missing link in the new backend design:
+        self.backend.set_viewport_transform(s.offset_x, s.offset_y, s.scale)
 
     def set_virtual_resolution(self, width: int, height: int):
         self._viewport.set_virtual_resolution(int(width), int(height))
-        # re-apply using current window size
-        w, h = self.size
+        w, h = self.backend.window.size()
+        self.size = (w, h)
         self._viewport.resize(w, h)
+        self._apply_viewport_transform()
 
     def set_viewport_mode(self, mode: ViewportMode):
         self._viewport.set_mode(mode)
+        # mode change affects scale/offset
+        if self._viewport.state is not None:
+            self._apply_viewport_transform()
 
     def get_viewport(self) -> ViewportState:
         return self._viewport.state
 
     def screen_to_virtual(self, x: float, y: float) -> tuple[float, float]:
-        return self._viewport.screen_to_virtual(x, y)
+        logical_w, logical_h = self.size
+        drawable_w, drawable_h = self._drawable_size
+
+        sx = drawable_w / logical_w if logical_w else 1.0
+        sy = drawable_h / logical_h if logical_h else 1.0
+
+        return self._viewport.screen_to_virtual(x * sx, y * sy)
 
     def set_title(self, title):
-        self.backend.set_window_title(title)
+        self.backend.window.set_title(title)
 
     def set_clear_color(self, r, g, b):
-        self.backend.set_clear_color(r, g, b)
+        self.backend.render.set_clear_color(r, g, b)
 
     def on_window_resized(self, width: int, height: int):
         logger.debug(f"Window resized event: {width}x{height}")
-        width = int(width)
-        height = int(height)
 
-        # Update cached size, but DO NOT call backend.resize_window here.
-        self.size = (width, height)
-        self.window_settings.width = width
-        self.window_settings.height = height
+        # logical
+        logical_w, logical_h = int(width), int(height)
+
+        # drawable (pixel)
+        drawable_w, drawable_h = self.backend.window.drawable_size()
+
+        # store both if useful
+        self.size = (logical_w, logical_h)
+        self._drawable_size = (drawable_w, drawable_h)
 
-        self._viewport.resize(width, height)
+        # viewport should match what renderer draws to:
+        self._viewport.resize(drawable_w, drawable_h)
+        self._apply_viewport_transform()
 
     def get_virtual_size(self) -> tuple[int, int]:
         s = self.get_viewport()

mini_arcade_core/runtime/window/window_port.py

@@ -4,28 +4,14 @@ Service interfaces for runtime components.
 
 from __future__ import annotations
 
-from mini_arcade_core.backend import Backend, WindowSettings
+from typing import Protocol
+
 from mini_arcade_core.engine.render.viewport import ViewportMode, ViewportState
 
 
-class WindowPort:
+class WindowPort(Protocol):
     """Interface for window-related operations."""
 
-    backend: Backend
-    size: tuple[int, int]
-    window_settings_cls: WindowSettings
-
-    def set_window_size(self, width: int, height: int):
-        """
-        Set the size of the window.
-
-        :param width: Width in pixels.
-        :type width: int
-
-        :param height: Height in pixels.
-        :type height: int
-        """
-
     def set_viewport_mode(self, mode: ViewportMode):
         """
         Set the viewport mode for rendering.

mini_arcade_core/scenes/debug_overlay.py

@@ -4,11 +4,12 @@ Debug overlay scene that displays FPS, window size, and scene stack information.
 
 from __future__ import annotations
 
+from mini_arcade_core.backend.backend import Backend
 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
+from mini_arcade_core.scenes.sim_scene import SimScene
 
 
 @register_scene("debug_overlay")
@@ -55,14 +56,14 @@ class DebugOverlayScene(SimScene):
         for e in stack:
             lines.append(f"  - {e.scene_id} overlay={e.is_overlay}")
 
-        def draw(backend):
+        def draw(backend: Backend):
             # translucent background panel
-            backend.draw_rect(
+            backend.render.draw_rect(
                 8, 8, 360, 18 * (len(lines) + 1), color=(0, 0, 0, 0.65)
             )
             y = 14
             for line in lines:
-                backend.draw_text(
+                backend.text.draw(
                     16, y, line, color=(255, 255, 255), font_size=14
                 )
                 y += 18

mini_arcade_core/scenes/registry.py

@@ -15,7 +15,7 @@ from mini_arcade_core.runtime.context import RuntimeContext
 from .autoreg import snapshot
 
 if TYPE_CHECKING:
-    from mini_arcade_core.sim.protocols import SimScene
+    from mini_arcade_core.scenes.sim_scene import SimScene
 
 
 class SceneFactory(Protocol):
@@ -34,6 +34,16 @@ class SceneRegistry:
 
     _factories: Dict[str, SceneFactory]
 
+    @property
+    def listed_scene_ids(self) -> list[str]:
+        """
+        Get a list of all registered scene IDs.
+
+        :return: A list of registered scene IDs.
+        :rtype: list[str]
+        """
+        return list(self._factories.keys())
+
     def register(self, scene_id: str, factory: SceneFactory):
         """
         Register a scene factory under a given scene ID.

mini_arcade_core/scenes/sim_scene.py

@@ -5,15 +5,23 @@ Defines the SimScene protocol for simulation scenes.
 
 from __future__ import annotations
 
-from typing import Protocol, runtime_checkable
+from dataclasses import dataclass
 
 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
 
 
-@runtime_checkable
-class SimScene(Protocol):
-    """ "Protocol for a simulation scene in the mini arcade core."""
+@dataclass
+class SimScene:
+    """
+    Simulation-first scene protocol.
+    tick() advances the simulation and returns a RenderPacket for this scene.
+
+    :ivar context: RuntimeContext for this scene.
+    """
+
+    context: RuntimeContext
 
     def on_enter(self):
         """Called when the scene is entered."""
@@ -21,9 +29,9 @@ class SimScene(Protocol):
     def on_exit(self):
         """Called when the scene is exited."""
 
-    def tick(self, input_frame: InputFrame, dt: float):
+    def tick(self, input_frame: InputFrame, dt: float) -> RenderPacket:
         """
-        Advance the simulation by one tick.
+        Advance the simulation by dt seconds, processing input_frame.
 
         :param input_frame: Current input frame.
         :type input_frame: InputFrame
@@ -31,11 +39,3 @@ class SimScene(Protocol):
         :param dt: Delta time since last tick.
         :type dt: float
         """
-
-    def build_render_packet(self) -> RenderPacket:
-        """
-        Build the render packet for the current scene state.
-
-        :return: RenderPacket instance.
-        :rtype: RenderPacket
-        """

mini_arcade_core/ui/menu.py

@@ -15,8 +15,8 @@ from mini_arcade_core.engine.commands import Command, CommandQueue, QuitCommand
 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.sim_scene import SimScene
 from mini_arcade_core.scenes.systems.system_pipeline import SystemPipeline
-from mini_arcade_core.sim.protocols import SimScene
 from mini_arcade_core.spaces.d2.geometry2d import Size2D
 
 
@@ -271,12 +271,15 @@ class Menu:
 
         # 0) Solid background (for main menus)
         if self.style.background_color is not None:
-            surface.draw_rect(0, 0, vw, vh, color=self.style.background_color)
+            surface.render.draw_rect(
+                0, 0, vw, vh, color=self.style.background_color
+            )
 
         # 1) Overlay (for pause, etc.)
         if self.style.overlay_color is not None:
-            surface.draw_rect(0, 0, vw, vh, color=self.style.overlay_color)
-
+            surface.render.draw_rect(
+                0, 0, vw, vh, color=self.style.overlay_color
+            )
         # 2) Compute menu content bounds (panel area)
         content_w, content_h, title_h = self._measure_content(surface)
 
@@ -292,7 +295,7 @@ class Menu:
 
         # 3) Panel (optional)
         if self.style.panel_color is not None:
-            surface.draw_rect(
+            surface.render.draw_rect(
                 x0, y0, panel_w, panel_h, color=self.style.panel_color
             )
 
@@ -357,7 +360,7 @@ class Menu:
         else:
             max_label_w = 0
             for it in self.items:
-                w, _ = surface.measure_text(
+                w, _ = surface.text.measure(
                     it.label, font_size=self.style.item_font_size
                 )
                 max_label_w = max(max_label_w, w)
@@ -384,18 +387,22 @@ class Menu:
             )
 
             # Border rect
-            surface.draw_rect(x - 4, y - 4, bw + 8, bh + 8, color=border)
+            surface.render.draw_rect(
+                x - 4, y - 4, bw + 8, bh + 8, color=border
+            )
             # Fill rect
-            surface.draw_rect(x, y, bw, bh, color=self.style.button_fill)
+            surface.render.draw_rect(
+                x, y, bw, bh, color=self.style.button_fill
+            )
 
             # Label color
             text_color = self.style.selected if selected else self.style.normal
-            tw, th = surface.measure_text(
+            tw, th = surface.text.measure(
                 item.label, font_size=self.style.item_font_size
             )
             tx = x + (bw - tw) // 2
             ty = y + (bh - th) // 2
-            surface.draw_text(
+            surface.text.draw(
                 tx,
                 ty,
                 item.label,
@@ -412,7 +419,7 @@ class Menu:
 
         # Title
         if self.title:
-            tw, th = surface.measure_text(
+            tw, th = surface.text.measure(
                 self.title, font_size=self.style.title_font_size
             )
             max_w = max(max_w, tw)
@@ -433,7 +440,7 @@ class Menu:
             else:
                 max_label_w = 0
                 for it in self.items:
-                    w, _ = surface.measure_text(
+                    w, _ = surface.text.measure(
                         it.label, font_size=self.style.item_font_size
                     )
                     max_label_w = max(max_label_w, w)
@@ -446,7 +453,7 @@ class Menu:
             items_h = len(self.items) * bh + (len(self.items) - 1) * gap
         else:
             for it in self.items:
-                w, _ = surface.measure_text(
+                w, _ = surface.text.measure(
                     it.label, font_size=self.style.item_font_size
                 )
                 max_w = max(max_w, w)
@@ -480,13 +487,33 @@ class Menu:
         color: Color,
         font_size: int | None = None,
     ):
-        w, _ = surface.measure_text(text, font_size=font_size)
-        surface.draw_text(
+        w, _ = surface.text.measure(text, font_size=font_size)
+        surface.text.draw(
             x_center - (w // 2), y, text, color=color, font_size=font_size
         )
 
     # pylint: enable=too-many-arguments
 
+    def set_viewport(self, viewport: Size2D):
+        """
+        Set the viewport size for the menu.
+
+        :param viewport: New viewport size.
+        :type viewport: Size2D
+        """
+        if self.viewport is None:
+            self.viewport = viewport
+            return
+
+        old_w, old_h = self.viewport
+        new_w, new_h = viewport
+        self.viewport = viewport
+
+        # If the viewport changed (especially shrinking), allow layout to shrink too.
+        if (new_w < old_w) or (new_h < old_h):
+            self._max_content_w_seen = 0
+            self._max_button_w_seen = 0
+
 
 # pylint: enable=too-many-instance-attributes
 
@@ -722,7 +749,7 @@ class BaseMenuScene(SimScene):
     def on_enter(self):
         self.menu = Menu(
             self._build_display_items(),
-            viewport=self.context.services.window.get_virtual_size(),
+            viewport=self.menu_viewport(),
             title=self.menu_title,
             style=self.menu_style(),
         )
@@ -738,6 +765,7 @@ class BaseMenuScene(SimScene):
         )
 
     def tick(self, input_frame: InputFrame, dt: float) -> RenderPacket:
+        self.menu.set_viewport(self.menu_viewport())
         items = self.menu_items()
         if not items:
             return RenderPacket()
@@ -761,6 +789,16 @@ class BaseMenuScene(SimScene):
         # always return packet from pipeline
         return ctx.packet or RenderPacket()
 
+    def menu_viewport(self) -> Size2D:
+        """
+        Get the viewport size for the menu.
+
+        :return: The Size2D representing the menu viewport.
+        :rtype: Size2D
+        """
+        # default: virtual space (fits your UI layout)
+        return self.context.services.window.get_virtual_size()
+
     def _build_display_items(self) -> list[MenuItem]:
         """
         Resolve dynamic labels (label_fn(ctx)) into the label field the Menu draws.

mini_arcade_core/utils/__init__.py

@@ -6,5 +6,6 @@ from __future__ import annotations
 
 from .deprecated_decorator import deprecated
 from .logging import logger
+from .profiler import FrameTimer
 
-__all__ = ["logger", "deprecated"]
+__all__ = ["logger", "deprecated", "FrameTimer"]

mini_arcade_core/utils/logging.py

@@ -82,6 +82,29 @@ LOGGER_FORMAT = (
 )
 
 
+class OnlyPerf(logging.Filter):
+    """Performance logger filter to include only perf logs."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return record.name.startswith("mini-arcade-core.perf")
+
+
+class ExcludePerf(logging.Filter):
+    """Performance logger filter to exclude perf logs."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        return not record.name.startswith("mini-arcade-core.perf")
+
+
+class PerfFormatter(logging.Formatter):
+    """Formatter for performance logs."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        # No global level color wrap; let the message carry its own ANSI
+        ts = self.formatTime(record, "%Y-%m-%d %H:%M:%S")
+        return f"{ts} [{record.levelname:<8}] [mini-arcade-core]\nprofiler:\n{record.getMessage()}"
+
+
 def _enable_windows_ansi():
     """
     Best-effort enable ANSI escape sequences on Windows terminals.
@@ -141,27 +164,33 @@ def configure_logging(level: int = logging.DEBUG):
     # Avoid duplicate handlers if reloaded/imported multiple times
     # We tag our handler so we can find it reliably.
     handler_tag = "_mini_arcade_core_console_handler"
+    perf_tag = "_mini_arcade_core_perf_handler"
 
+    # --- main console handler (your current one) ---
+    main_console = None
     for h in list(root.handlers):
         if getattr(h, handler_tag, False):
-            # Already configured
-            return
-
-    console = logging.StreamHandler(stream=sys.stdout)
-    setattr(console, handler_tag, True)
-
-    console.setFormatter(ConsoleColorFormatter(LOGGER_FORMAT))
-    console.addFilter(EnsureClassName())
-
-    # Important: don’t leave any basicConfig handlers around if someone called it earlier
-    # We remove only the plain StreamHandlers that don't have our tag.
-    for h in list(root.handlers):
-        if isinstance(h, logging.StreamHandler) and not getattr(
-            h, handler_tag, False
-        ):
-            root.removeHandler(h)
-
-    root.addHandler(console)
+            main_console = h
+            break
+
+    if main_console is None:
+        main_console = logging.StreamHandler(stream=sys.stdout)
+        setattr(main_console, handler_tag, True)
+        main_console.setFormatter(ConsoleColorFormatter(LOGGER_FORMAT))
+        main_console.addFilter(EnsureClassName())
+        root.addHandler(main_console)
+
+    # EXCLUDE perf logs from main handler (prevents duplicates)
+    main_console.addFilter(ExcludePerf())
+
+    # --- perf handler (new) ---
+    already = any(getattr(h, perf_tag, False) for h in root.handlers)
+    if not already:
+        perf_console = logging.StreamHandler(stream=sys.stdout)
+        setattr(perf_console, perf_tag, True)
+        perf_console.setFormatter(PerfFormatter())
+        perf_console.addFilter(OnlyPerf())
+        root.addHandler(perf_console)
 
 
 configure_logging()