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

mini_arcade_core/runtime/scene/scene_adapter.py

@@ -1,125 +0,0 @@
-"""
-Module providing runtime adapters for window and scene management.
-"""
-
-from __future__ import annotations
-
-from mini_arcade_core.runtime.context import RuntimeContext
-from mini_arcade_core.runtime.scene.scene_port import (
-    SceneEntry,
-    ScenePolicy,
-    ScenePort,
-    StackItem,
-)
-
-
-class SceneAdapter(ScenePort):
-    """
-    Manages multiple scenes (not implemented).
-    """
-
-    def __init__(self, registry, game):
-        self._registry = registry
-        self._stack = []
-        self._game = game
-
-    @property
-    def current_scene(self):
-        return self._stack[-1].entry.scene if self._stack else None
-
-    @property
-    def visible_stack(self):
-        return [e.scene for e in self.visible_entries()]
-
-    def change(self, scene_id):
-        self.clean()
-        self.push(scene_id, as_overlay=False)
-
-    def push(
-        self,
-        scene_id,
-        *,
-        as_overlay=False,
-        policy=None,
-    ):
-        # default policy based on overlay vs base
-        if policy is None:
-            # base scenes: do not block anything by default
-            policy = ScenePolicy()
-        runtime_context = RuntimeContext.from_game(self._game)
-        scene = self._registry.create(
-            scene_id, runtime_context
-        )  # or whatever your factory call is
-        scene.on_enter()
-
-        entry = SceneEntry(
-            scene_id=scene_id,
-            scene=scene,
-            is_overlay=as_overlay,
-            policy=policy,
-        )
-        self._stack.append(StackItem(entry=entry))
-
-    def pop(self):
-        if not self._stack:
-            return
-        item = self._stack.pop()
-        item.entry.scene.on_exit()
-
-    def clean(self):
-        while self._stack:
-            self.pop()
-
-    def quit(self):
-        self._game.quit()
-
-    def visible_entries(self):
-        entries = [i.entry for i in self._stack]
-        # find highest opaque from top down; render starting there
-        for idx in range(len(entries) - 1, -1, -1):
-            if entries[idx].policy.is_opaque:
-                return entries[idx:]
-        return entries
-
-    def update_entries(self):
-        vis = self.visible_entries()
-        if not vis:
-            return []
-        out = []
-        for entry in reversed(vis):  # top->down
-            out.append(entry)
-            if entry.policy.blocks_update:
-                break
-        return list(reversed(out))  # bottom->top order
-
-    def input_entry(self):
-        vis = self.visible_entries()
-        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):
-        # 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/runtime/scene/scene_port.py

@@ -1,170 +0,0 @@
-"""
-Service interfaces for runtime components.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, List
-
-from mini_arcade_core.scenes.registry import SceneRegistry
-
-if TYPE_CHECKING:
-    from mini_arcade_core.engine.game import Game
-    from mini_arcade_core.scenes.scene import Scene
-    from mini_arcade_core.sim.protocols import SimScene
-
-
-@dataclass(frozen=True)
-class ScenePolicy:
-    """
-    Controls how a scene behaves in the scene stack.
-
-    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)
-class SceneEntry:
-    """
-    An entry in the scene stack.
-
-    :ivar scene_id (str): Identifier of the scene.
-    :ivar scene (Scene): The scene instance.
-    :ivar is_overlay (bool): Whether the scene is an overlay.
-    :ivar policy (ScenePolicy): The scene's policy.
-    """
-
-    scene_id: str
-    scene: SimScene
-    is_overlay: bool
-    policy: ScenePolicy
-
-
-@dataclass
-class StackItem:
-    """
-    An item in the scene stack.
-
-    :ivar entry (SceneEntry): The scene entry.
-    """
-
-    entry: SceneEntry
-
-
-class ScenePort:
-    """Interface for scene management operations."""
-
-    _registry: SceneRegistry
-    _stack: List[StackItem]
-    _game: Game
-
-    @property
-    def current_scene(self) -> "SimScene | None":
-        """
-        Get the currently active scene.
-
-        :return: The active Scene instance, or None if no scene is active.
-        :rtype: SimScene | None
-        """
-
-    @property
-    def visible_stack(self) -> List["SimScene"]:
-        """
-        Return the list of scenes that should be drawn (base + overlays).
-        We draw from the top-most non-overlay scene upward.
-
-        :return: List of visible Scene instances.
-        :rtype: List[SimScene]
-        """
-
-    def change(self, scene_id: str):
-        """
-        Change the current scene to the specified scene.
-
-        :param scene_id: Identifier of the scene to switch to.
-        :type scene_id: str
-        """
-
-    def push(self, scene_id: str, *, as_overlay: bool = False):
-        """
-        Push a new scene onto the scene stack.
-
-        :param scene_id: Identifier of the scene to push.
-        :type scene_id: str
-
-        :param as_overlay: Whether to push the scene as an overlay.
-        :type as_overlay: bool
-        """
-
-    def pop(self) -> "Scene | None":
-        """
-        Pop the current scene from the scene stack.
-
-        :return: The popped Scene instance, or None if the stack was empty.
-        :rtype: Scene | None
-        """
-
-    def clean(self):
-        """
-        Clean up all scenes from the scene stack.
-        """
-
-    def quit(self):
-        """
-        Quit the game
-        """
-
-    def visible_entries(self) -> list[SceneEntry]:
-        """
-        Render from bottom->top unless an opaque entry exists; if so,
-            render only from that entry up.
-
-        :return: List of SceneEntry instances to render.
-        :rtype: list[SceneEntry]
-        """
-
-    def update_entries(self) -> list[SceneEntry]:
-        """
-        Tick/update scenes considering blocks_update.
-        Typical: pause overlay blocks update below it.
-
-        :return: List of SceneEntry instances to update.
-        :rtype: list[SceneEntry]
-        """
-
-    def input_entry(self) -> SceneEntry | None:
-        """
-        Who gets input this frame. If top blocks_input, only it receives input.
-        If not, top still gets input (v1 simple). Later you can allow fall-through.
-
-        :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):
-        """
-        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/sim/protocols.py

@@ -1,41 +0,0 @@
-"""
-Simulation scene protocol module.
-Defines the SimScene protocol for simulation scenes.
-"""
-
-from __future__ import annotations
-
-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
-
-
-@dataclass
-class SimScene:
-    """
-    Simulation-first scene protocol.
-
-    tick() advances the simulation and returns a RenderPacket for this scene.
-    """
-
-    context: RuntimeContext
-
-    def on_enter(self):
-        """Called when the scene is entered."""
-
-    def on_exit(self):
-        """Called when the scene is exited."""
-
-    def tick(self, input_frame: InputFrame, dt: float) -> RenderPacket:
-        """
-        Advance the simulation by dt seconds, processing input_frame.
-
-        :param input_frame: InputFrame with input events for this frame.
-        :param dt: Time delta in seconds since the last tick.
-
-        :return: RenderPacket for this frame.
-        :rtype: RenderPacket
-        """
-        raise NotImplementedError()

mini_arcade_core/sim/runner.py

@@ -1,222 +0,0 @@
-"""
-Simulation runner module.
-Defines the SimRunner class for running simulation scenes.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from time import perf_counter, sleep
-from typing import Dict, Optional
-
-from mini_arcade_core.backend import Backend
-from mini_arcade_core.engine.render.packet import RenderPacket
-from mini_arcade_core.engine.render.pipeline import RenderPipeline
-from mini_arcade_core.runtime.input_frame import InputFrame
-from mini_arcade_core.runtime.scene.scene_port import SceneEntry
-from mini_arcade_core.runtime.services import RuntimeServices
-
-
-def _neutral_input(frame_index: int, dt: float) -> InputFrame:
-    # InputFrame is frozen; create a clean snapshot for non-input scenes.
-    return InputFrame(frame_index=frame_index, dt=dt)
-
-
-def _has_tick(scene: object) -> bool:
-    # Avoid isinstance(..., Protocol). Structural check.
-    return callable(getattr(scene, "tick", None))
-
-
-def _has_draw(scene: object) -> bool:
-    return callable(getattr(scene, "draw", None))
-
-
-def _has_update(scene: object) -> bool:
-    return callable(getattr(scene, "update", None))
-
-
-def _has_handle_event(scene: object) -> bool:
-    return callable(getattr(scene, "handle_event", None))
-
-
-@dataclass(frozen=True)
-class SimRunnerConfig:
-    """
-    Config for sim runner.
-
-    - record: if True, capture a frame each tick using deterministic naming.
-    - run_id: required when record=True.
-    - max_frames: optional safety stop (useful for offline sims/tests).
-    """
-
-    fps: int = 60
-    record: bool = False
-    run_id: str = "run"
-    max_frames: Optional[int] = None
-    # If True, still forward raw events to the input scene's handle_event (legacy UI / text input).
-    forward_events_to_input_scene: bool = True
-
-
-class SimRunner:
-    """
-    Simulation-first runner.
-
-    Uses:
-      - services.scenes.update_entries() for ticking (policy-aware)
-      - services.scenes.visible_entries() for rendering (opaque-aware)
-      - services.scenes.input_entry() for input focus
-    """
-
-    def __init__(
-        self,
-        backend: Backend,
-        services: RuntimeServices,
-        *,
-        render_pipeline: Optional[RenderPipeline] = None,
-    ):
-        if services.scenes is None:
-            raise ValueError("RuntimeServices.scenes must be set")
-        if services.input is None:
-            raise ValueError("RuntimeServices.input must be set")
-        if services.capture is None:
-            # recording is optional, but capture port should exist in v1
-            raise ValueError("RuntimeServices.capture must be set")
-
-        self.backend = backend
-        self.services = services
-        self.pipeline = render_pipeline or RenderPipeline()
-
-        # cache: scene object id -> last RenderPacket
-        self._packets: Dict[int, RenderPacket] = {}
-
-        self._running: bool = False
-
-    def stop(self):
-        """
-        Stop the simulation loop.
-        """
-        self._running = False
-
-    # TODO: Solve too-many-statements, too-many-branches and too-many-locals
-    # warning later
-    # Justification: The run method orchestrates multiple complex steps in the
-    # simulation loop.
-    # pylint: disable=too-many-statements,too-many-branches,too-many-locals
-    def run(
-        self, initial_scene_id: str, *, cfg: Optional[SimRunnerConfig] = None
-    ):
-        """
-        Run the simulation loop starting from the initial scene.
-
-        :param initial_scene_id: ID of the initial scene to load.
-        :type initial_scene_id: str
-
-        :param cfg: Optional SimRunnerConfig instance.
-        :type cfg: Optional[SimRunnerConfig]
-        """
-        cfg = cfg or SimRunnerConfig()
-
-        scenes = self.services.scenes
-        assert scenes is not None
-
-        # start at initial scene
-        scenes.change(initial_scene_id)
-
-        self._running = True
-        target_dt = 1.0 / cfg.fps if cfg.fps > 0 else 0.0
-
-        last_time = perf_counter()
-        frame_index = 0
-
-        while self._running:
-            if cfg.max_frames is not None and frame_index >= cfg.max_frames:
-                break
-
-            now = perf_counter()
-            dt = now - last_time
-            last_time = now
-
-            # 1) poll events -> build InputFrame
-            events = list(self.backend.poll_events())
-            input_frame = self.services.input.build(events, frame_index, dt)
-
-            # 2) OS quit request is a hard stop
-            if input_frame.quit:
-                # use ScenePort.quit so Game.quit can be centralized there
-                scenes.quit()
-                break
-
-            # 3) input focus scene (top of visible stack)
-            input_entry: Optional[SceneEntry] = scenes.input_entry()
-            if input_entry is None:
-                break
-
-            # Optional legacy: forward raw events to focused scene
-            if cfg.forward_events_to_input_scene and _has_handle_event(
-                input_entry.scene
-            ):
-                for ev in events:
-                    input_entry.scene.handle_event(ev)
-
-            # 4) tick/update policy-aware scenes
-            for entry in scenes.update_entries():
-                scene_obj = entry.scene
-                scene_key = id(scene_obj)
-
-                # Only the input-focused scene receives the actual input_frame
-                effective_input = (
-                    input_frame
-                    if entry is input_entry
-                    else _neutral_input(frame_index, dt)
-                )
-
-                if _has_tick(scene_obj):
-                    packet = scene_obj.tick(effective_input, dt)  # SimScene
-                    if not isinstance(packet, RenderPacket):
-                        raise TypeError(
-                            f"{entry.scene_id}.tick() must "
-                            f"return RenderPacket, got {type(packet)!r}"
-                        )
-                    self._packets[scene_key] = packet
-                elif _has_update(scene_obj):
-                    # legacy scene; keep packet cache if any
-                    scene_obj.update(dt)
-
-            # 5) render visible stack (policy-aware)
-            self.backend.begin_frame()
-
-            for entry in scenes.visible_entries():
-                scene_obj = entry.scene
-                scene_key = id(scene_obj)
-
-                if _has_tick(scene_obj):
-                    packet = self._packets.get(scene_key)
-                    # If first frame and no packet exists yet, do a dt=0 tick to bootstrap
-                    if packet is None:
-                        packet = scene_obj.tick(
-                            _neutral_input(frame_index, 0.0), 0.0
-                        )
-                        self._packets[scene_key] = packet
-                    self.pipeline.draw_packet(self.backend, packet)
-
-                elif _has_draw(scene_obj):
-                    # legacy scene draw path
-                    scene_obj.draw(self.backend)
-
-            self.backend.end_frame()
-
-            # 6) deterministic capture (optional)
-            if cfg.record:
-                # label could be "frame" or something semantic later
-                self.services.capture.screenshot_sim(
-                    cfg.run_id, frame_index, label="frame"
-                )
-
-            # 7) frame pacing
-            if target_dt > 0 and dt < target_dt:
-                sleep(target_dt - dt)
-
-            frame_index += 1
-
-        # cleanup scenes
-        scenes.clean()

mini_arcade_core-1.1.1.dist-info/RECORD

@@ -1,85 +0,0 @@
-mini_arcade_core/__init__.py,sha256=axwl7fiQ2Zu2vPOTMUxwnvR746gI9RhpBWpBCId_yqo,3686
-mini_arcade_core/backend/__init__.py,sha256=E9uOCttCkXwdN_5MlcFHUmG3Bj6RYMatNNOno4C_6aI,312
-mini_arcade_core/backend/backend.py,sha256=1-lgjkcftYaeusWKhQrDTwgfbwH6y9S-PP-miy7tRNE,8619
-mini_arcade_core/backend/events.py,sha256=5Ohve3CQ6n2CztiOhbCoz6yFDY4z0j4v4R9FBKRDRjc,2929
-mini_arcade_core/backend/keys.py,sha256=LTg20SwLBI3kpPIiTNpq2yBft_QUGj-iNFSNm9M-Fus,3010
-mini_arcade_core/backend/sdl_map.py,sha256=_yBRtvaFUcQKy1kcoIf-SPhbbKEW7dzvzBcI6TLmKjc,2060
-mini_arcade_core/backend/types.py,sha256=SuiwXGNmXCZxfPsww6zj3V_NK7k4jpoCuzMn19afS-g,175
-mini_arcade_core/bus.py,sha256=2Etpoa-UWhk33xJjqDlY5YslPDJEjxNoIEVtF3C73vs,1558
-mini_arcade_core/engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/engine/commands.py,sha256=SfhncRQvuwTQg5BEyS8yeFTaq5mixiFsvFUZSBK9y1Q,5420
-mini_arcade_core/engine/game.py,sha256=HaLCew31UD8ujz3yOHGjWPzjpD7dkeQSMDdnMFD9JtI,15588
-mini_arcade_core/engine/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/engine/render/context.py,sha256=1zzycXDbQnK3wuk79cMjSewu8FinAp-EsFal7bbJFnI,1414
-mini_arcade_core/engine/render/effects/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/engine/render/effects/base.py,sha256=yq8qRZMbp4VTi02WnVbyHS3RYc56vvP69MzPbCO3m2s,2373
-mini_arcade_core/engine/render/effects/crt.py,sha256=D8_7Bqzt_VeLusyXzeLQynxTIZwQ45NisSImTB-4Hpg,2141
-mini_arcade_core/engine/render/effects/registry.py,sha256=ie1nuLJbQq9Ecb9tea3oGvSD9QaydbFFhH8ggEf-9uU,1220
-mini_arcade_core/engine/render/effects/vignette.py,sha256=ogLTgaJ9srpiA59Lc7_nBD7wZk7y6t9HnHYNoK7YeSE,2569
-mini_arcade_core/engine/render/frame_packet.py,sha256=nYHvR7CHlIZa6ZazmPO2dU2P91vEkBjBzUVQGrOkaYc,624
-mini_arcade_core/engine/render/packet.py,sha256=OiAPwGoVHo04OcUWMAoA_N1AFPUMyf8yxNgJthGj4-c,1440
-mini_arcade_core/engine/render/passes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/engine/render/passes/base.py,sha256=LWgWhfafbCvRKIFbt3koW-ibjYxMfKOIXyLNazCakcM,864
-mini_arcade_core/engine/render/passes/begin_frame.py,sha256=Yzlk8bv7mgjlnM1jH_kYjJ_d8469i8aPriEqv7hm9gE,699
-mini_arcade_core/engine/render/passes/end_frame.py,sha256=ONFcNQJhYvaN-BK6wyxxsLDBUUHx-b-mvOYH__QXJJ4,760
-mini_arcade_core/engine/render/passes/lighting.py,sha256=ugmHHNNZWArL_Xs6-1SQIxLptUTQwe4M2sSPEk8X-7s,677
-mini_arcade_core/engine/render/passes/postfx.py,sha256=OWcayjffZr5xT7cNIsbm4gzxmGfYiQyLgycV2dC6Jsg,1417
-mini_arcade_core/engine/render/passes/ui.py,sha256=JxMXI900le45nOZF2SzDuniVqUOJYvAbSDRxYcIFFkc,1122
-mini_arcade_core/engine/render/passes/world.py,sha256=QPKDVkKk-AA7ZR1HCo-JfzjxjUT6vmxXbqo1BYpebiU,1550
-mini_arcade_core/engine/render/pipeline.py,sha256=bp2pOuwwBvJjYWZJgNe6xTfEBwdEm5WiBnM8infV_AI,3268
-mini_arcade_core/engine/render/render_service.py,sha256=1ueir8MZ6Six5gAHt5StoICPAbyppX4DqzWb8HEuS9g,531
-mini_arcade_core/engine/render/viewport.py,sha256=fbzH3_rc27IGUtDalmxz5cukwHnpt1kopIeVqmTab20,5784
-mini_arcade_core/managers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/managers/cheats.py,sha256=jMx2a8YnaNCkCG5MPmIzz4uHuS7-_aYf0J45cv2-3v0,5569
-mini_arcade_core/managers/inputs.py,sha256=9HZ0BnJyUX-elfGETPhhPZnTkz2bK83pEKj7GHPbPFU,8523
-mini_arcade_core/runtime/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/runtime/audio/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/runtime/audio/audio_adapter.py,sha256=9ithbInYUB72ErwvlNrbIlI55uw0DT2QD33geYNXT3c,522
-mini_arcade_core/runtime/audio/audio_port.py,sha256=3Mqv7TchEVkmd-RVjUpCD-EqA-yiL0Jf2Sj3rQwP678,907
-mini_arcade_core/runtime/capture/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/runtime/capture/capture_adapter.py,sha256=qJ2JiOLJHbP00IesbAyyPGPBxSaxwPJRTMaMjMU4bXs,4660
-mini_arcade_core/runtime/capture/capture_port.py,sha256=NVxMJrQJELiSYuUJ29tvsdIcCBq4f1dTT2rDLZs6gnI,1230
-mini_arcade_core/runtime/context.py,sha256=IQpAhtbN0ZqJVXG6KXFq3FPk0sIGyPmyNgBYviqZl7A,1632
-mini_arcade_core/runtime/file/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/runtime/file/file_adapter.py,sha256=09q7G9Qijml9d4AAjo6HLC1yuoVTjE_7xaT8apT4mk0,523
-mini_arcade_core/runtime/file/file_port.py,sha256=p1MouCSHXZw--rWNMw3aYBLU-of8mXaT_suopczPtM8,608
-mini_arcade_core/runtime/input/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/runtime/input/input_adapter.py,sha256=vExQiwFIWTI3zYD8lmnD9TvoQPZvJfI6IINPJUqAdQ0,1467
-mini_arcade_core/runtime/input/input_port.py,sha256=d4ptftwf92_LJdyaUMFxIsLHXBINzQyJACHn4laNyxQ,746
-mini_arcade_core/runtime/input_frame.py,sha256=34-RAfOD-YScVLyRQrarpm7byFTHjsWM77lIH0JsmT8,2384
-mini_arcade_core/runtime/render/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/runtime/render/render_port.py,sha256=Sqp-JBh-iRzzGtgnO_nU1KiJEqyrTYPRDQbg04HdR0A,507
-mini_arcade_core/runtime/scene/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/runtime/scene/scene_adapter.py,sha256=RthYyp_G3c9YVVQlnCuvtgFFtp9zvdjcykc0fXEpmic,3473
-mini_arcade_core/runtime/scene/scene_port.py,sha256=t6-REznEVvxcJoq2DJXcDs8sg0nC9fww6J5NwGpweg8,4473
-mini_arcade_core/runtime/services.py,sha256=dtatQisOAdWgdqGjrH0cO1GA6ZDt4CiXjOEzlaNL51E,1165
-mini_arcade_core/runtime/window/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/runtime/window/window_adapter.py,sha256=_yCcJwvHN0gEPh0rkgLEKtPZ50qRbONsUTbgtV1m7Y8,2689
-mini_arcade_core/runtime/window/window_port.py,sha256=JbSH549De7fa4ifQ0EH5QQoq03Got1n9C4qViLgciUU,2682
-mini_arcade_core/scenes/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/scenes/autoreg.py,sha256=wsuY7YUSZFmDyToKHFriAG78OU48-7J4BfL_X6T5GBg,1037
-mini_arcade_core/scenes/debug_overlay.py,sha256=pe5eXmxVl0itBdlt5Q-TEyGNiONMztMeck6Vq93QCmo,2423
-mini_arcade_core/scenes/registry.py,sha256=SKjaw1e2EHvLimxe4ixf0DFxQTJRVQxRi96MujGgCao,3376
-mini_arcade_core/scenes/sim_scene.py,sha256=b2JsOvPFkHCdCf8pMLJZ90qB0JJ6B8Ka3o5QK4cVshI,1055
-mini_arcade_core/scenes/systems/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/scenes/systems/base_system.py,sha256=GfMrXsO8ynW3xOxWeav7Ug5XUbRnbF0vo8VzmG7gpec,1075
-mini_arcade_core/scenes/systems/system_pipeline.py,sha256=Cy9y1DclbMLZZ-yx7OKYe34ORoGLNa6dReQfOdiO8SY,1642
-mini_arcade_core/sim/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/sim/protocols.py,sha256=b7d2WAKRokTNbteNhUaWdGx9vc9Fnccxb-5rPwozDaA,1099
-mini_arcade_core/sim/runner.py,sha256=ZF-BZJw-NcaFrg4zsUu1zOUUBZwZbRYflqcdF1jDcmM,7446
-mini_arcade_core/spaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/spaces/d2/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/spaces/d2/boundaries2d.py,sha256=xeTnd0pW5DKfqaKsfSBXnufeb45aXNIspgHRyLXWejo,2804
-mini_arcade_core/spaces/d2/collision2d.py,sha256=5IvgLnyVb8i0uzzZuum1noWsNhoxcvHOLaHkmrTMTxQ,1710
-mini_arcade_core/spaces/d2/geometry2d.py,sha256=FuYzef-XdOyb1aeGLJbxINxr0WJHnqFFBgtbPi1WonY,1716
-mini_arcade_core/spaces/d2/kinematics2d.py,sha256=AJ3DhPXNgm6wZYwCljMIE4_2BYx3E2rPcwhXTgQALkU,2030
-mini_arcade_core/spaces/d2/physics2d.py,sha256=OQT7r-zMtmoKD2aWCSNmRAdI0OGIpxGX-pLR8LcAMbQ,1854
-mini_arcade_core/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mini_arcade_core/ui/menu.py,sha256=pUC6qfG3lNXa1Ga2Kz_cSgjiAfAWVMRevum61G_RE8k,24646
-mini_arcade_core/utils/__init__.py,sha256=3Q9r6bTyqImYix8BnOGwWjAz25nbTQezGcRq3m5KEYE,189
-mini_arcade_core/utils/deprecated_decorator.py,sha256=yrrW2ZqPskK-4MUTyIrMb465Wc54X2poV53ZQutZWqc,1140
-mini_arcade_core/utils/logging.py,sha256=YyirsGRSpGtxegUl3HWz37mGNngK3QkYm2_aZjXJC84,5279
-mini_arcade_core-1.1.1.dist-info/METADATA,sha256=uLI8iX6Z3XyhoHBQDw4vmWfXRkk-09IXqUvHMvwHrJQ,8188
-mini_arcade_core-1.1.1.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-mini_arcade_core-1.1.1.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
-mini_arcade_core-1.1.1.dist-info/RECORD,,