mini-arcade-core 0.9.9__py3-none-any.whl → 1.0.0__py3-none-any.whl

mini_arcade_core/game.py

@@ -1,287 +0,0 @@
-"""
-Game core module defining the Game class and configuration.
-"""
-
-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, Literal, Union
-
-from PIL import Image  # type: ignore[import]
-
-from mini_arcade_core.backend import Backend
-from mini_arcade_core.scenes import SceneRegistry
-
-if TYPE_CHECKING:  # avoid runtime circular import
-    from mini_arcade_core.scenes import Scene
-
-SceneOrId = Union["Scene", str]
-
-
-@dataclass
-class GameConfig:
-    """
-    Configuration options for the Game.
-
-    :ivar width: Width of the game window in pixels.
-    :ivar height: Height of the game window in pixels.
-    :ivar title: Title of the game window.
-    :ivar fps: Target frames per second.
-    :ivar background_color: RGB background color.
-    :ivar backend: Optional Backend instance to use for rendering and input.
-    """
-
-    width: int = 800
-    height: int = 600
-    title: str = "Mini Arcade Game"
-    fps: int = 60
-    background_color: tuple[int, int, int] = (0, 0, 0)
-    backend: Backend | None = None
-
-
-Difficulty = Literal["easy", "normal", "hard", "insane"]
-
-
-@dataclass
-class GameSettings:
-    """
-    Game settings that can be modified during gameplay.
-
-    :ivar difficulty: Current game difficulty level.
-    """
-
-    difficulty: Difficulty = "normal"
-
-
-@dataclass
-class _StackEntry:
-    scene: "Scene"
-    as_overlay: bool = False
-
-
-class Game:
-    """Core game object responsible for managing the main loop and active scene."""
-
-    def __init__(
-        self, config: GameConfig, registry: SceneRegistry | None = None
-    ):
-        """
-        :param config: Game configuration options.
-        :type config: GameConfig
-
-        :param registry: Optional SceneRegistry for scene management.
-        :type registry: SceneRegistry | None
-
-        :raises ValueError: If the provided config does not have a valid Backend.
-        """
-        self.config = config
-        self._current_scene: Scene | None = None
-        self._running: bool = False
-
-        if config.backend is None:
-            raise ValueError(
-                "GameConfig.backend must be set to a Backend instance"
-            )
-        self.backend: Backend = config.backend
-        self.registry = registry or SceneRegistry(_factories={})
-        self._scene_stack: list[_StackEntry] = []
-        self.settings = GameSettings()
-
-    def current_scene(self) -> "Scene | None":
-        """
-        Get the currently active scene.
-
-        :return: The active Scene instance, or None if no scene is active.
-        :rtype: Scene | None
-        """
-        return self._scene_stack[-1].scene if self._scene_stack else None
-
-    def change_scene(self, scene: SceneOrId):
-        """
-        Swap the active scene. Concrete implementations should call
-        ``on_exit``/``on_enter`` appropriately.
-
-        :param scene: The new scene to activate.
-        :type scene: SceneOrId
-        """
-        scene = self._resolve_scene(scene)
-
-        while self._scene_stack:
-            entry = self._scene_stack.pop()
-            entry.scene.on_exit()
-
-        self._scene_stack.append(_StackEntry(scene=scene, as_overlay=False))
-        scene.on_enter()
-
-    def push_scene(self, scene: SceneOrId, as_overlay: bool = False):
-        """
-        Push a scene on top of the current one.
-        If as_overlay=True, underlying scene(s) may still be drawn but never updated.
-
-        :param scene: The scene to push onto the stack.
-        :type scene: SceneOrId
-
-        :param as_overlay: Whether to treat the scene as an overlay.
-        :type as_overlay: bool
-        """
-        scene = self._resolve_scene(scene)
-
-        top = self.current_scene()
-        if top is not None:
-            top.on_pause()
-
-        self._scene_stack.append(
-            _StackEntry(scene=scene, as_overlay=as_overlay)
-        )
-        scene.on_enter()
-
-    def pop_scene(self) -> "Scene | None":
-        """
-        Pop the top scene. If stack becomes empty, quit.
-
-        :return: The popped Scene instance, or None if the stack is now empty.
-        :rtype: Scene | None
-        """
-        if not self._scene_stack:
-            return None
-
-        popped = self._scene_stack.pop()
-        popped.scene.on_exit()
-
-        top = self.current_scene()
-        if top is None:
-            self.quit()
-            return popped.scene
-
-        top.on_resume()
-        return popped.scene
-
-    def _visible_stack(self) -> list["Scene"]:
-        """
-        Return the list of scenes that should be drawn (base + overlays).
-        We draw from the top-most non-overlay scene upward.
-        """
-        if not self._scene_stack:
-            return []
-
-        # find top-most base scene (as_overlay=False)
-        base_idx = 0
-        for i in range(len(self._scene_stack) - 1, -1, -1):
-            if not self._scene_stack[i].as_overlay:
-                base_idx = i
-                break
-
-        return [e.scene for e in self._scene_stack[base_idx:]]
-
-    def quit(self):
-        """Request that the main loop stops."""
-        self._running = False
-
-    def run(self, initial_scene: SceneOrId):
-        """
-        Run the main loop starting with the given scene.
-
-        This is intentionally left abstract so you can plug pygame, pyglet,
-        or another backend.
-
-        :param initial_scene: The scene to start the game with.
-        :type initial_scene: SceneOrId
-        """
-        backend = self.backend
-        backend.init(self.config.width, self.config.height, self.config.title)
-
-        br, bg, bb = self.config.background_color
-        backend.set_clear_color(br, bg, bb)
-
-        self.change_scene(initial_scene)
-
-        self._running = True
-        target_dt = 1.0 / self.config.fps if self.config.fps > 0 else 0.0
-        last_time = perf_counter()
-
-        while self._running:
-            now = perf_counter()
-            dt = now - last_time
-            last_time = now
-
-            top = self.current_scene()
-            if top is None:
-                break
-
-            for ev in backend.poll_events():
-                top.handle_event(ev)
-
-            top.update(dt)
-
-            backend.begin_frame()
-            for scene in self._visible_stack():
-                scene.draw(backend)
-            backend.end_frame()
-
-            if target_dt > 0 and dt < target_dt:
-                sleep(target_dt - dt)
-
-        # exit remaining scenes
-        while self._scene_stack:
-            entry = self._scene_stack.pop()
-            entry.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
-        # Justification: Pillow can raise various exceptions on failure
-        # pylint: disable=broad-exception-caught
-        except Exception:
-            return False
-        # pylint: enable=broad-exception-caught
-
-    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}"
-        bmp_path = os.path.join(directory, f"{filename}.bmp")
-
-        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
-
-    def _resolve_scene(self, scene: SceneOrId) -> "Scene":
-        if isinstance(scene, str):
-            return self.registry.create(scene, self)
-        return scene

mini_arcade_core/keymaps/__init__.py

@@ -1,15 +0,0 @@
-"""
-Keymaps for Mini Arcade Core.
-Includes key definitions and default key mappings.
-"""
-
-from __future__ import annotations
-
-from .keys import Key, keymap
-from .sdl import SDL_KEYCODE_TO_KEY
-
-__all__ = [
-    "Key",
-    "keymap",
-    "SDL_KEYCODE_TO_KEY",
-]

mini_arcade_core/managers/base.py

@@ -1,91 +0,0 @@
-"""
-Base manager classes for handling collections of items.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-from typing import Callable, Generic, Iterable, List, Protocol, TypeVar
-
-from mini_arcade_core.backend.backend import Backend
-
-# ---- shared types ----
-T = TypeVar("T")
-OverlayFunc = Callable[[Backend], None]
-
-
-class Drawable(Protocol):
-    """Defines a drawable entity."""
-
-    def draw(self, surface: Backend):
-        """
-        Draw the entity on the given surface.
-
-        :param surface: The backend surface to draw on.
-        :type surface: Backend
-        """
-
-
-class Updatable(Protocol):
-    """Defines an updatable entity."""
-
-    def update(self, dt: float):
-        """
-        Update the entity state.
-
-        :param dt: Time delta in seconds.
-        :type dt: float
-        """
-
-
-class EntityLike(Drawable, Updatable, Protocol):
-    """Defines a game entity."""
-
-
-@dataclass
-class ListManager(Generic[T]):
-    """
-    Generic manager for a list of items.
-
-    :ivar items (List[T]): List of managed items.
-    """
-
-    items: List[T] = field(default_factory=list)
-
-    def add(self, *items: T):
-        """
-        Add one or more items to the manager.
-
-        :param items: One or more items to add.
-        :type items: T
-        """
-        self.items.extend(items)
-
-    def add_many(self, items: Iterable[T]):
-        """
-        Add multiple items to the manager.
-
-        :param items: An iterable of items to add.
-        :type items: Iterable[T]
-        """
-        self.items.extend(items)
-
-    def remove(self, item: T):
-        """
-        Remove a single item from the manager, if present.
-
-        :param item: The item to remove.
-        :type item: T
-        """
-        if item in self.items:
-            self.items.remove(item)
-
-    def clear(self):
-        """Clear all items from the manager."""
-        self.items.clear()
-
-    def __iter__(self):
-        return iter(self.items)
-
-    def __len__(self) -> int:
-        return len(self.items)

mini_arcade_core/managers/entity_manager.py

@@ -1,38 +0,0 @@
-"""
-Entity manager for handling a collection of entities.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from mini_arcade_core.backend import Backend
-
-from .base import EntityLike, ListManager
-
-
-@dataclass
-class EntityManager(ListManager[EntityLike]):
-    """
-    Manages a collection of entities within a scene.
-    """
-
-    def update(self, dt: float):
-        """
-        Update all managed entities.
-
-        :param dt: Time delta in seconds.
-        :type dt: float
-        """
-        for ent in list(self.items):
-            ent.update(dt)
-
-    def draw(self, surface: "Backend"):
-        """
-        Draw all managed entities.
-
-        :param surface: The backend surface to draw on.
-        :type surface: Backend
-        """
-        for ent in list(self.items):
-            ent.draw(surface)

mini_arcade_core/managers/overlay_manager.py

@@ -1,33 +0,0 @@
-"""
-Overlay manager for handling a collection of overlays.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Callable
-
-from mini_arcade_core.backend import Backend
-from mini_arcade_core.managers.base import ListManager
-
-if TYPE_CHECKING:
-    from mini_arcade_core.game import Game
-
-OverlayFunc = Callable[[Backend], None]
-
-
-@dataclass
-class OverlayManager(ListManager[OverlayFunc]):
-    """
-    Manages a collection of overlays within a scene.
-    """
-
-    def draw(self, surface: "Backend"):
-        """
-        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.items:
-            overlay(surface)

mini_arcade_core/scenes/scene.py

@@ -1,93 +0,0 @@
-"""
-Base class for game scenes (states/screens).
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, List, Optional
-
-from mini_arcade_core.backend import Backend, Event
-from mini_arcade_core.entity import Entity
-from mini_arcade_core.managers import EntityManager, OverlayManager
-from mini_arcade_core.two_d import Size2D
-
-if TYPE_CHECKING:
-    from mini_arcade_core.game import Game
-
-
-@dataclass
-class SceneServices:
-    """
-    Container for scene services like entity and overlay managers.
-
-    :ivar entities: EntityManager for managing scene entities.
-    :ivar overlays: OverlayManager for managing scene overlays.
-    """
-
-    entities: EntityManager = field(default_factory=EntityManager)
-    overlays: OverlayManager = field(default_factory=OverlayManager)
-
-
-class Scene(ABC):
-    """Base class for game scenes (states/screens)."""
-
-    def __init__(
-        self,
-        game: Game,
-        *,
-        services: Optional[SceneServices] = None,
-    ):
-        """
-        :param game: Reference to the main Game object.
-        :type game: Game
-        """
-        self.game = game
-        self.entities: List[Entity] = []
-        self.size: Size2D = Size2D(game.config.width, game.config.height)
-
-        self.services: SceneServices = (
-            services if services is not None else SceneServices()
-        )
-
-    @abstractmethod
-    def on_enter(self):
-        """Called when the scene becomes active."""
-
-    @abstractmethod
-    def on_exit(self):
-        """Called when the scene is replaced."""
-
-    @abstractmethod
-    def handle_event(self, event: Event):
-        """
-        Handle input / events (e.g. pygame.Event).
-
-        :param event: The event to handle.
-        :type event: Event
-        """
-
-    @abstractmethod
-    def update(self, dt: float):
-        """
-        Update game logic. ``dt`` is the delta time in seconds.
-
-        :param dt: Time delta in seconds.
-        :type dt: float
-        """
-
-    @abstractmethod
-    def draw(self, surface: Backend):
-        """
-        Render to the main surface.
-
-        :param surface: The backend surface to draw on.
-        :type surface: Backend
-        """
-
-    def on_pause(self):
-        """Called when the game is paused."""
-
-    def on_resume(self):
-        """Called when the game is resumed."""

mini_arcade_core/two_d/__init__.py

@@ -1,30 +0,0 @@
-"""
-Two-dimensional utilities and components for Mini Arcade Core.
-Includes 2D entities, boundaries, and physics.
-"""
-
-from __future__ import annotations
-
-from .boundaries2d import (
-    RectKinematic,
-    RectSprite,
-    VerticalBounce,
-    VerticalWrap,
-)
-from .collision2d import RectCollider
-from .geometry2d import Bounds2D, Position2D, Size2D
-from .kinematics2d import KinematicData
-from .physics2d import Velocity2D
-
-__all__ = [
-    "Bounds2D",
-    "Position2D",
-    "Size2D",
-    "KinematicData",
-    "Velocity2D",
-    "RectCollider",
-    "RectKinematic",
-    "RectSprite",
-    "VerticalBounce",
-    "VerticalWrap",
-]

mini_arcade_core-0.9.9.dist-info/RECORD

@@ -1,31 +0,0 @@
-mini_arcade_core/__init__.py,sha256=m9wELq1seQQE13tfU6DT7XinC07yzo5KTS1KEA0MQNs,3804
-mini_arcade_core/backend/__init__.py,sha256=w-6QTUngdIYZuvEU3B8zL-vXyKbyLDVucbt7yKZdLlc,379
-mini_arcade_core/backend/backend.py,sha256=dLXTtLn5qURftWOWOVQd2ouuZmJpbiOl11KMIDRk2us,4026
-mini_arcade_core/backend/events.py,sha256=usn2HTk5-5ZiaU2IjbrNRpEj_4uoaiqfY3qufQLYy0w,2929
-mini_arcade_core/backend/types.py,sha256=SuiwXGNmXCZxfPsww6zj3V_NK7k4jpoCuzMn19afS-g,175
-mini_arcade_core/cheats.py,sha256=J0HPLUC6sARXNl_CtUaWhWoo9A0vEjQcIHP6XJUPrNQ,7133
-mini_arcade_core/entity.py,sha256=vDe2v7GajyGaqckBYeD3cjs--pOTFrDNhMIdf7PZsJQ,1759
-mini_arcade_core/game.py,sha256=C8flMXn_DMHWDmr5FVrTey_nUHabwja8wSaialNMcLg,8526
-mini_arcade_core/keymaps/__init__.py,sha256=_5Y5_61XT5TsOhbb6p2EPzvjCNN9hCPoxTgj_TAfBvA,258
-mini_arcade_core/keymaps/keys.py,sha256=LTg20SwLBI3kpPIiTNpq2yBft_QUGj-iNFSNm9M-Fus,3010
-mini_arcade_core/keymaps/sdl.py,sha256=Tb0amkbmYjYkEkYnMZ6i9QWjwXBkEHIm13-gEMUYENM,2060
-mini_arcade_core/managers/__init__.py,sha256=ZpWVxqUq2lbLdrtPR75ipSmykp3fpm9nQrQHP15sGJI,352
-mini_arcade_core/managers/base.py,sha256=D2CCde_zbsrlLNzs3v3qgYpRu9QgmFlzOfdfFIwf5xs,2023
-mini_arcade_core/managers/entity_manager.py,sha256=mBgSFgdZ73f5ZZ-_GtvnqOFWuSySX5QJZrZ77sH4qes,831
-mini_arcade_core/managers/overlay_manager.py,sha256=LTywwhSigjGiCKqULBGjKJPT6xyYgeoKXfhPEoOw8Nk,801
-mini_arcade_core/scenes/__init__.py,sha256=MXaWaDvwf0ycd5GZ_9DhPQ7tWqsp-ECWTOZpGZarcRE,323
-mini_arcade_core/scenes/autoreg.py,sha256=b4V0jaA65I2hnT2f___rg_pT556OjrtoNjIRdZrXBaI,1009
-mini_arcade_core/scenes/registry.py,sha256=0B3iSvepydwMpELQz8cRaQeAU0pR1Fz9O1YtWshLjQw,3226
-mini_arcade_core/scenes/scene.py,sha256=MrHAHf-su6xrLXi4y1opxJWy0YF-yLfSN6rOvSHPqCc,2384
-mini_arcade_core/two_d/__init__.py,sha256=iWjm39RYDEshxSmiIWyGWa6Qr9O2gnHfOpzrl63FUro,626
-mini_arcade_core/two_d/boundaries2d.py,sha256=H1HkCR1422MkQIEve2DFKvnav4RpvtLx-qTMxzmdDMQ,2610
-mini_arcade_core/two_d/collision2d.py,sha256=jR5bOmqUaedxRzwFoKBgn7k-ozwklB4RP9pUTVk6aUw,1716
-mini_arcade_core/two_d/geometry2d.py,sha256=js791mMpsE_YbEoqtTOsOxNSflvKgSk6VeVKhj9N318,1282
-mini_arcade_core/two_d/kinematics2d.py,sha256=NFMiIzDYqDquyg_EhD7EQBJ_Sz4RncmkEjfls9NwkPs,2102
-mini_arcade_core/two_d/physics2d.py,sha256=qIq86qWVuvcnLIMEPH6xx7XQO4tQhfiMZY6FseuVOR8,1636
-mini_arcade_core/ui/__init__.py,sha256=RmcZXfBFFmL09j_Bo1LHagRjiKYajuySPilIUNjc3KQ,248
-mini_arcade_core/ui/menu.py,sha256=J3hYY46xOHLN65WSet4-cnQU7L5pu48scjLJUW9IkEM,13681
-mini_arcade_core-0.9.9.dist-info/METADATA,sha256=G7IK6yFjXiaGPHQr9_DcedeRXQAmhWlgXCcjyHslr1U,8188
-mini_arcade_core-0.9.9.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-mini_arcade_core-0.9.9.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
-mini_arcade_core-0.9.9.dist-info/RECORD,,