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

mini_arcade_core/backend/backend.py

@@ -289,3 +289,36 @@ class Backend(Protocol):
     def clear_clip_rect(self):
         """Clear any clipping rectangle."""
         raise NotImplementedError
+
+    # Justification: Simple drawing API for now
+    # 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),
+    ):
+        """
+        Draw a line between two points in some default color.
+
+        :param x1: X position of the start point.
+        :type x1: int
+
+        :param y1: Y position of the start point.
+        :type y1: int
+
+        :param x2: X position of the end point.
+        :type x2: int
+
+        :param y2: Y position of the end point.
+        :type y2: int
+
+        :param color: RGB color tuple.
+        :type color: tuple[int, ...]
+        """
+        raise NotImplementedError
+
+
+# pylint: enable=too-many-arguments,too-many-positional-arguments

mini_arcade_core/engine/commands.py

@@ -197,3 +197,22 @@ class ToggleDebugOverlayCommand(Command):
                 receives_input=False,
             ),
         )
+
+
+@dataclass(frozen=True)
+class ToggleEffectCommand(Command):
+    """
+    Toggle a post-processing effect on or off.
+
+    :ivar effect_id (str): Identifier of the effect to toggle.
+    """
+
+    effect_id: str
+
+    def execute(self, context: CommandContext) -> None:
+        # effects live in context.meta OR in a dedicated service/settings.
+        # v1 simplest: stash stack into context.settings or context.services.render
+        stack = getattr(context.settings, "effects_stack", None)
+        if stack is None:
+            return
+        stack.toggle(self.effect_id)

mini_arcade_core/engine/game.py

@@ -16,8 +16,16 @@ from mini_arcade_core.engine.commands import (
     CommandQueue,
     QuitCommand,
     ToggleDebugOverlayCommand,
+    ToggleEffectCommand,
 )
 from mini_arcade_core.engine.render.context import RenderContext
+from mini_arcade_core.engine.render.effects.base import (
+    EffectParams,
+    EffectStack,
+)
+from mini_arcade_core.engine.render.effects.crt import CRTEffect
+from mini_arcade_core.engine.render.effects.registry import EffectRegistry
+from mini_arcade_core.engine.render.effects.vignette import VignetteNoiseEffect
 from mini_arcade_core.engine.render.frame_packet import FramePacket
 from mini_arcade_core.engine.render.packet import RenderPacket
 from mini_arcade_core.engine.render.pipeline import RenderPipeline
@@ -52,6 +60,19 @@ class WindowConfig:
     title: str
 
 
+@dataclass
+class PostFXConfig:
+    """
+    Configuration for post-processing effects.
+
+    :ivar enabled (bool): Whether post effects are enabled by default.
+    :ivar active (list[str]): List of active effect IDs by default.
+    """
+
+    enabled: bool = True
+    active: list[str] = field(default_factory=list)
+
+
 @dataclass
 class GameConfig:
     """
@@ -65,6 +86,7 @@ class GameConfig:
     window: WindowConfig | None = None
     fps: int = 60
     backend: Backend | None = None
+    postfx: PostFXConfig = field(default_factory=PostFXConfig)
 
 
 Difficulty = Literal["easy", "normal", "hard", "insane"]
@@ -79,6 +101,7 @@ class GameSettings:
     """
 
     difficulty: Difficulty = "normal"
+    effects_stack: EffectStack | None = None
 
 
 def _neutral_input(frame_index: int, dt: float) -> InputFrame:
@@ -204,6 +227,9 @@ class Game:
     # TODO: Fix too-many-statements and too-many-locals warnings
     # Justification: Main game loop with multiple responsibilities.
     # pylint: disable=too-many-statements,too-many-locals
+    # TODO: Fix too-many-branches warning
+    # Justification: Complex control flow in main loop.
+    # pylint: disable=too-many-branches
     def run(self, initial_scene_id: str):
         """
         Run the main loop starting with the given scene.
@@ -222,6 +248,26 @@ class Game:
 
         pipeline = RenderPipeline()
 
+        effects_registry = EffectRegistry()
+        effects_registry.register(CRTEffect())
+        effects_registry.register(VignetteNoiseEffect())
+
+        effects_stack = EffectStack(
+            enabled=self.config.postfx.enabled,
+            active=list(self.config.postfx.active),
+            params={
+                "crt": EffectParams(intensity=0.35, wobble_speed=1.0),
+                "vignette_noise": EffectParams(
+                    intensity=0.25, wobble_speed=1.0
+                ),
+            },
+        )
+        self.settings.effects_stack = effects_stack
+
+        for p in pipeline.passes:
+            if getattr(p, "name", "") == "PostFXPass":
+                p.registry = effects_registry
+
         self._running = True
         target_dt = 1.0 / self.config.fps if self.config.fps > 0 else 0.0
         last_time = perf_counter()
@@ -238,6 +284,7 @@ class Game:
         # & self.services.scenes.input_entry
         # Justification: These methods are expected to return values.
         # pylint: disable=assignment-from-no-return
+        time_s = 0.0
 
         while self._running:
             timer.clear()
@@ -255,8 +302,17 @@ class Game:
                     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())
+                if e.type == EventType.KEYDOWN:
+                    if e.key == Key.F1:
+                        self.command_queue.push(ToggleDebugOverlayCommand())
+                    elif e.key == Key.F2:
+                        self.command_queue.push(ToggleEffectCommand("crt"))
+                    elif e.key == Key.F3:
+                        self.command_queue.push(
+                            ToggleEffectCommand("vignette_noise")
+                        )
+                    elif e.key == Key.F4:
+                        effects_stack.enabled = not effects_stack.enabled
             timer.mark("events_polled")
 
             input_frame = self.services.input.build(events, frame_index, dt)
@@ -334,6 +390,10 @@ class Game:
                 debug_overlay=getattr(self.settings, "debug_overlay", False),
                 frame_ms=dt * 1000.0,
             )
+            time_s += dt
+            render_ctx.meta["frame_index"] = frame_index
+            render_ctx.meta["time_s"] = time_s
+            render_ctx.meta["effects_stack"] = effects_stack
 
             self.services.render.last_frame_ms = render_ctx.frame_ms
             self.services.render.last_stats = render_ctx.stats

mini_arcade_core/engine/render/effects/base.py

@@ -0,0 +1,88 @@
+"""
+Screen-space post effects base classes and protocols.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Protocol, runtime_checkable
+
+from mini_arcade_core.backend import Backend
+from mini_arcade_core.engine.render.context import RenderContext
+
+
+@runtime_checkable
+class Effect(Protocol):
+    """
+    Screen-space post effect.
+
+    IMPORTANT: Effects should draw ONLY using ctx.viewport (screen-space),
+    and must not assume anything about world-space transforms.
+    """
+
+    effect_id: str
+
+    def apply(self, backend: Backend, ctx: RenderContext) -> None:
+        """
+        Apply the effect to the current framebuffer.
+
+        :param backend: Backend to use for rendering.
+        :type backend: Backend
+
+        :param ctx: Render context with viewport info.
+        :type ctx: RenderContext
+        """
+
+
+@dataclass
+class EffectParams:
+    """
+    Shared params (Material-ish controls) for v1.
+
+    :ivar intensity (float): Effect intensity.
+    :ivar wobble_speed (float): Speed factor for animated distortion.
+    :ivar tint (tuple[int, int, int, int] | None): Optional RGBA tint.
+    """
+
+    intensity: float = 1.0
+    wobble_speed: float = 1.0
+    tint: tuple[int, int, int, int] | None = None
+
+
+@dataclass
+class EffectStack:
+    """
+    Runtime state: what effects are enabled + their params.
+
+    Zero-overhead path:
+        - if enabled=False OR active is empty => PostFXPass returns immediately.
+
+    :ivar enabled (bool): Master toggle for post effects.
+    :ivar active (list[str]): List of active effect IDs.
+    :ivar params (dict[str, EffectParams]): Per-effect parameters.
+    """
+
+    enabled: bool = False
+    active: list[str] = field(default_factory=list)
+    params: dict[str, EffectParams] = field(default_factory=dict)
+
+    def is_active(self) -> bool:
+        """
+        Check if any effects are active.
+
+        :return: True if effects are enabled and at least one is active.
+        :rtype: bool
+        """
+        return self.enabled and bool(self.active)
+
+    def toggle(self, effect_id: str) -> None:
+        """
+        Toggle an effect on/off.
+
+        :param effect_id: ID of the effect to toggle.
+        :type effect_id: str
+        """
+        if effect_id in self.active:
+            self.active.remove(effect_id)
+        else:
+            self.active.append(effect_id)

mini_arcade_core/engine/render/effects/crt.py

@@ -0,0 +1,68 @@
+"""
+CRT screen-space post effect.
+"""
+
+# Justification: PoC code for v1.
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from math import sin
+
+from mini_arcade_core.backend import Backend
+from mini_arcade_core.engine.render.context import RenderContext
+from mini_arcade_core.engine.render.effects.base import EffectParams
+
+
+@dataclass
+class CRTEffect:
+    """
+    CRT screen-space post effect.
+    Simulates CRT scanlines with optional wobble.
+    """
+
+    effect_id: str = "crt"
+
+    # Justification: This is PoC code for v1.
+    # pylint: disable=too-many-locals
+    def apply(self, backend: Backend, ctx: RenderContext) -> None:
+        """Apply the CRT effect to the current render context."""
+        vp = ctx.viewport
+        x0, y0 = vp.offset_x, vp.offset_y
+        w, h = vp.viewport_w, vp.viewport_h
+
+        stack = ctx.meta.get("effects_stack")
+        params: EffectParams = (
+            stack.params.get(self.effect_id, EffectParams())
+            if stack
+            else EffectParams()
+        )
+
+        intensity = max(0.0, min(1.0, params.intensity))
+        if intensity <= 0.0:
+            return
+
+        # Use a time value from ctx.meta (added in Game.run below)
+        t = float(ctx.meta.get("time_s", 0.0))
+        wobble = float(params.wobble_speed)
+
+        # Clip to viewport so it works with all viewport modes/resolutions
+        backend.set_clip_rect(x0, y0, w, h)
+
+        # Scanlines: draw every N lines with low alpha
+        # Note: assumes Backend supports alpha in color tuples.
+        spacing = 2  # tweakable
+        base_alpha = 120  # int(40 * intensity)  # subtle
+        line_color = (255, 255, 255, base_alpha)
+
+        # "Wobble": tiny horizontal shift that animates over time
+        # Keep it tiny to avoid looking like a bug.
+        for y in range(y0, y0 + h, spacing):
+            # shift in pixels, -2..2-ish
+            shift = int(2.0 * intensity * sin((y * 0.05) + (t * wobble)))
+            backend.draw_line(
+                x0 + shift, y, x0 + w + shift, y, color=line_color
+            )
+
+        backend.clear_clip_rect()

mini_arcade_core/engine/render/effects/registry.py

@@ -0,0 +1,50 @@
+"""
+Screen-space post effects registry.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+
+from mini_arcade_core.engine.render.effects.base import Effect
+
+
+@dataclass
+class EffectRegistry:
+    """
+    Registry of available screen-space post effects.
+
+    :ivar _effects: dict[str, Effect]: Internal mapping of effect IDs to effects.
+    """
+
+    _effects: dict[str, Effect] = field(default_factory=dict)
+
+    def register(self, effect: Effect) -> None:
+        """
+        Register a new effect in the registry.
+
+        :param effect: Effect to register.
+        :type effect: Effect
+        """
+        self._effects[effect.effect_id] = effect
+
+    def get(self, effect_id: str) -> Effect | None:
+        """
+        Get an effect by its ID.
+
+        :param effect_id: ID of the effect to retrieve.
+        :type effect_id: str
+
+        :return: Effect instance or None if not found.
+        :rtype: Effect | None
+        """
+        return self._effects.get(effect_id)
+
+    def all_ids(self) -> list[str]:
+        """
+        Get a list of all registered effect IDs.
+
+        :return: List of effect IDs.
+        :rtype: list[str]
+        """
+        return list(self._effects.keys())

mini_arcade_core/engine/render/effects/vignette.py

@@ -0,0 +1,79 @@
+"""
+Vignette noise screen-space post effect.
+"""
+
+# Justification: PoC code for v1.
+# pylint: disable=duplicate-code
+
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+
+from mini_arcade_core.backend import Backend
+from mini_arcade_core.engine.render.context import RenderContext
+from mini_arcade_core.engine.render.effects.base import EffectParams
+
+
+@dataclass
+class VignetteNoiseEffect:
+    """
+    Vignette + noise screen-space post effect.
+    Simulates a vignette effect with added noise/grain.
+    """
+
+    effect_id: str = "vignette_noise"
+
+    # Justification: This is PoC code for v1.
+    # pylint: disable=too-many-locals
+    def apply(self, backend: Backend, ctx: RenderContext) -> None:
+        """Apply the Vignette + Noise effect to the current render context."""
+        vp = ctx.viewport
+        x0, y0 = vp.offset_x, vp.offset_y
+        w, h = vp.viewport_w, vp.viewport_h
+
+        stack = ctx.meta.get("effects_stack")
+        params: EffectParams = (
+            stack.params.get(self.effect_id, EffectParams())
+            if stack
+            else EffectParams()
+        )
+
+        intensity = max(0.0, min(1.0, params.intensity))
+        if intensity <= 0.0:
+            return
+
+        backend.set_clip_rect(x0, y0, w, h)
+
+        # Vignette approximation: draw edge rectangles with increasing alpha.
+        # Not a true radial gradient, but good enough for v1.
+        steps = 10
+        max_alpha = int(110 * intensity)  # subtle
+        for i in range(steps):
+            # thickness grows inward
+            t = i + 1
+            alpha = int(max_alpha * (t / steps))
+            color = (0, 0, 0, alpha)
+
+            # top
+            backend.draw_rect(x0, y0, w, t, color=color)
+            # bottom
+            backend.draw_rect(x0, y0 + h - t, w, t, color=color)
+            # left
+            backend.draw_rect(x0, y0, t, h, color=color)
+            # right
+            backend.draw_rect(x0 + w - t, y0, t, h, color=color)
+
+        # Noise: sprinkle a few pixels (or tiny 1x1 rects).
+        # Use deterministic-ish seed per frame so it doesn't “swim” too much.
+        frame = int(ctx.meta.get("frame_index", 0))
+        random.seed(frame * 1337)
+
+        dots = int(200 * intensity)  # tweak
+        for _ in range(dots):
+            px = x0 + random.randint(0, max(0, w - 1))
+            py = y0 + random.randint(0, max(0, h - 1))
+            a = random.randint(10, int(50 * intensity) + 10)
+            backend.draw_rect(px, py, 1, 1, color=(255, 255, 255, a))
+
+        backend.clear_clip_rect()

mini_arcade_core/engine/render/passes/postfx.py

@@ -2,11 +2,14 @@
 Post-processing effects render pass implementation.
 """
 
+from __future__ import annotations
+
 from dataclasses import dataclass
 
 from mini_arcade_core.backend import Backend
 from mini_arcade_core.engine.render.context import RenderContext
-from mini_arcade_core.engine.render.packet import RenderPacket
+from mini_arcade_core.engine.render.effects.registry import EffectRegistry
+from mini_arcade_core.engine.render.frame_packet import FramePacket
 
 
 @dataclass
@@ -17,12 +20,30 @@ class PostFXPass:
     """
 
     name: str = "PostFXPass"
+    registry: EffectRegistry | None = None
 
     # Justification: No implementation yet
     # pylint: disable=unused-argument
     def run(
-        self, backend: Backend, ctx: RenderContext, packets: list[RenderPacket]
+        self, backend: Backend, ctx: RenderContext, packets: list[FramePacket]
     ):
         """Run the post-processing effects render pass."""
-        # hook/no-op for now (CRT later)
-        return
+        # Zero overhead path (no effects configured)
+        stack = ctx.meta.get("effects_stack")
+        if stack is None or not stack.is_active():
+            return
+
+        # Screen space: no transforms
+        backend.clear_viewport_transform()
+        backend.clear_clip_rect()
+
+        reg = self.registry
+        if reg is None:
+            # no registry => nothing to do
+            return
+
+        for effect_id in list(stack.active):
+            effect = reg.get(effect_id)
+            if effect is None:
+                continue
+            effect.apply(backend, ctx)

{mini_arcade_core-1.1.0.dist-info → mini_arcade_core-1.1.1.dist-info}/METADATA

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

{mini_arcade_core-1.1.0.dist-info → mini_arcade_core-1.1.1.dist-info}/RECORD

@@ -1,16 +1,21 @@
 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=RpFclQFDOLSaqCACWR0sT_OQYjDIfYzQaFvnHzURLvI,7788
+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=6GmuOfZjRDVJkWvgWZWOzcQFfOJRmuZeYk4Kz5gamr0,4848
-mini_arcade_core/engine/game.py,sha256=MMp0uOav5ws86WMH6NcKJKBIOpKlkxnE7zVpraW0bC0,13324
+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
@@ -18,7 +23,7 @@ mini_arcade_core/engine/render/passes/base.py,sha256=LWgWhfafbCvRKIFbt3koW-ibjYx
 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=gNbiluS5KUP121XazIFI0KkQTxspT4PEWy68jpIUqi8,734
+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
@@ -74,7 +79,7 @@ mini_arcade_core/ui/menu.py,sha256=pUC6qfG3lNXa1Ga2Kz_cSgjiAfAWVMRevum61G_RE8k,2
 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.0.dist-info/METADATA,sha256=dalAN3YwADbmrN53vpjbygAMZpMhRB1LCmEmX3W3v-M,8188
-mini_arcade_core-1.1.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-mini_arcade_core-1.1.0.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
-mini_arcade_core-1.1.0.dist-info/RECORD,,
+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,,