mini-arcade-core 0.10.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

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,132 +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 Overlay(Protocol):
-    """
-    Defines an overlay function.
-
-    :ivar enabled (bool): Whether the overlay is enabled.
-    """
-
-    enabled: bool
-
-    def update(self, dt: float):
-        """
-        Update the overlay state.
-
-        :param dt: Time delta in seconds.
-        :type dt: float
-        """
-
-    def draw(self, surface: "Backend"):
-        """
-        Draw the overlay on the given surface.
-
-        :param surface: The backend surface to draw on.
-        :type surface: Backend
-        """
-
-
-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 get(self, item: T) -> T | None:
-        """
-        Get an item from the manager.
-
-        :param item: The item to get.
-        :type item: T
-
-        :return: The item if found, else None.
-        :rtype: T | None
-        """
-        for it in self.items:
-            if it == item:
-                return it
-        return None
-
-    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/entities.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/overlays.py

@@ -1,53 +0,0 @@
-"""
-Overlay manager for handling a collection of overlays.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Union
-
-from mini_arcade_core.backend import Backend
-from mini_arcade_core.managers.base import ListManager, Overlay, OverlayFunc
-
-OverlayType = Union[Overlay, OverlayFunc]
-
-
-@dataclass
-class OverlayManager(ListManager[OverlayType]):
-    """
-    Manages a collection of overlays within a scene.
-    """
-
-    def update(self, dt: float):
-        """
-        Update all managed overlays.
-
-        :param dt: Time delta in seconds.
-        :type dt: float
-        """
-        for ov in list(self.items):
-            # class overlays only
-            if hasattr(ov, "update") and hasattr(ov, "draw"):
-                if getattr(ov, "enabled", True):
-                    ov.update(dt)
-
-    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
-        """
-
-        def prio(o: OverlayType) -> int:
-            """Priority for sorting overlays."""
-            return getattr(o, "priority", 0)
-
-        for ov in sorted(list(self.items), key=prio):
-            if hasattr(ov, "draw"):
-                if getattr(ov, "enabled", True):
-                    ov.draw(surface)
-            else:
-                # function overlay
-                ov(surface)

mini_arcade_core/managers/system.py

@@ -1,26 +0,0 @@
-"""
-Manager for scene systems.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-from mini_arcade_core.managers.base import ListManager
-from mini_arcade_core.scenes.system import BaseSceneSystem
-
-
-@dataclass
-class SystemManager(ListManager[BaseSceneSystem]):
-    """
-    Manager for scene systems.
-    """
-
-    def sorted(self) -> list[BaseSceneSystem]:
-        """
-        Get systems sorted by priority.
-
-        :return: List of systems sorted by priority.
-        :rtype: list[BaseSceneSystem]
-        """
-        return sorted(self.items, key=lambda s: getattr(s, "priority", 0))

mini_arcade_core/scenes/model.py

@@ -1,34 +0,0 @@
-"""
-Scene base model module.
-Provides the Scene class and related services.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, fields
-from typing import Any
-
-
-@dataclass
-class SceneModel:
-    """
-    Basic data model for a scene.
-    """
-
-    @staticmethod
-    def _serialize_dataclass(obj) -> dict[str, Any]:
-        out = {}
-        for f in fields(obj):
-            if f.metadata.get("serialize", True) is False:
-                continue
-            out[f.name] = getattr(obj, f.name)
-        return out
-
-    def to_dict(self) -> dict:
-        """
-        Convert the SceneModel to a dictionary.
-
-        :return: Dictionary representation of the SceneModel.
-        :rtype: dict
-        """
-        return self._serialize_dataclass(self)

mini_arcade_core/scenes/runtime.py

@@ -1,29 +0,0 @@
-"""
-Container for scene services like entity and overlay managers.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass, field
-
-from mini_arcade_core.managers.entities import EntityManager
-from mini_arcade_core.managers.inputs import InputManager
-from mini_arcade_core.managers.overlays import OverlayManager
-from mini_arcade_core.managers.system import SystemManager
-
-
-@dataclass
-class SceneRuntime:
-    """
-    Container for scene services like entity and overlay managers.
-
-    :ivar input (InputManager): InputManager for handling input bindings and commands.
-    :ivar entities (EntityManager): EntityManager for managing scene entities.
-    :ivar overlays (OverlayManager): OverlayManager for managing scene overlays.
-    :ivar systems (SystemManager): SystemManager for managing scene systems.
-    """
-
-    input: InputManager = field(default_factory=InputManager)
-    entities: EntityManager = field(default_factory=EntityManager)
-    overlays: OverlayManager = field(default_factory=OverlayManager)
-    systems: SystemManager = field(default_factory=SystemManager)

mini_arcade_core/scenes/scene.py

@@ -1,109 +0,0 @@
-"""
-Base class for game scenes (states/screens).
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-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.scenes.model import SceneModel
-from mini_arcade_core.spaces.d2 import Size2D
-
-from .runtime import SceneRuntime
-
-if TYPE_CHECKING:
-    from mini_arcade_core.game import Game
-
-
-class Scene(ABC):
-    """Base class for game scenes (states/screens)."""
-
-    model: SceneModel
-
-    def __init__(
-        self,
-        game: Game,
-        *,
-        services: Optional[SceneRuntime] = 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: SceneRuntime = (
-            services if services is not None else SceneRuntime()
-        )
-
-    @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 _systems_on_enter(self):
-        for sys in self.services.systems.sorted():
-            if getattr(sys, "enabled", True):
-                sys.on_enter()
-
-    def _systems_on_exit(self):
-        for sys in self.services.systems.sorted():
-            if getattr(sys, "enabled", True):
-                sys.on_exit()
-
-    def _systems_handle_event(self, event: Event) -> bool:
-        for sys in self.services.systems.sorted():
-            if getattr(sys, "enabled", True) and sys.handle_event(event):
-                return True
-        return False
-
-    def _systems_update(self, dt: float):
-        for sys in self.services.systems.sorted():
-            if getattr(sys, "enabled", True):
-                sys.update(dt)
-
-    def _systems_draw(self, surface: Backend):
-        for sys in self.services.systems.sorted():
-            if getattr(sys, "enabled", True):
-                sys.draw(surface)
-
-    def on_pause(self):
-        """Called when the game is paused."""
-
-    def on_resume(self):
-        """Called when the game is resumed."""

mini_arcade_core/scenes/system.py

@@ -1,69 +0,0 @@
-"""
-Protocol for scene systems.
-A scene system is a modular component that can hook into the scene lifecycle
-methods (on_enter, on_exit, handle_event, update, draw) to provide additional
-functionality.
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import TYPE_CHECKING
-
-from mini_arcade_core.backend import Backend, Event
-
-if TYPE_CHECKING:
-    from mini_arcade_core.scenes.scene import Scene
-
-
-@dataclass
-class BaseSceneSystem:
-    """
-    Protocol for scene systems.
-
-    :ivar enabled (bool): Whether the system is enabled.
-    :ivar priority (int): Priority of the system (lower runs first).
-    """
-
-    enabled: bool = True
-    priority: int = 0  # lower runs first
-
-    def __init__(self, scene: "Scene"):
-        self.scene = scene
-
-    def on_enter(self):
-        """
-        Called when the scene is entered.
-        """
-
-    def on_exit(self):
-        """
-        Called when the scene is exited.
-        """
-
-    def handle_event(self, event: "Event") -> bool:
-        """
-        Handle an event.
-
-        :param event: The event to handle.
-        :type event: Event
-
-        :return: True if the event was handled, False otherwise.
-        :rtype: bool
-        """
-
-    def update(self, dt: float):
-        """
-        Update the system.
-
-        :param dt: Delta time since last update.
-        :type dt: float
-        """
-
-    def draw(self, surface: "Backend"):
-        """
-        Draw the system.
-
-        :param surface: The backend surface to draw on.
-        :type surface: Backend
-        """

mini_arcade_core/ui/overlays.py

@@ -1,41 +0,0 @@
-"""
-Overlay base classes.
-"""
-
-from __future__ import annotations
-
-from mini_arcade_core.backend import Backend
-
-
-class BaseOverlay:
-    """
-    Base class for overlays.
-
-    :ivar enabled (bool): Whether the overlay is enabled.
-    :ivar priority (int): Drawing priority; lower values draw first.
-    """
-
-    enabled: bool = True
-    priority: int = 0  # lower draws first
-
-    # Justification for unused argument: method is intended to be overridden.
-    # pylint: disable=unused-argument
-    def update(self, dt: float):
-        """
-        Update the overlay state.
-
-        :param dt: Time delta in seconds.
-        :type dt: float
-        """
-        return
-
-    # pylint: enable=unused-argument
-
-    def draw(self, surface: "Backend"):
-        """
-        Draw the overlay on the given surface.
-
-        :param surface: The backend surface to draw on.
-        :type surface: Backend
-        """
-        raise NotImplementedError("draw() must be implemented by subclasses.")

mini_arcade_core-0.10.0.dist-info/RECORD

@@ -1,40 +0,0 @@
-mini_arcade_core/__init__.py,sha256=3b7F3LyUg7T8qFEy0USDMhgBpV6LCCcxxDvQ8FbaTeo,3588
-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/bus.py,sha256=2Etpoa-UWhk33xJjqDlY5YslPDJEjxNoIEVtF3C73vs,1558
-mini_arcade_core/commands.py,sha256=EpkiyJHuSVrSn410Z5MaeI64fzMoBi0WWA1HG8CQCG8,2185
-mini_arcade_core/entity.py,sha256=5GM3woFrBa6iDwuRbbXNQhUFyCIzpvlh5yI4yrOKZUo,1833
-mini_arcade_core/game.py,sha256=FipqmTMn3g5BB64dQ_VtoA6rssc3N9et90Mg6RKNflM,8535
-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=rLSNjilmAyNTR6djGfpFTahdwKQIBuNUTdZ8sQNjUoI,520
-mini_arcade_core/managers/base.py,sha256=8mfPaOO9j-lx3Uw4a2YJStdwZ5PjRaDCWusfxu5LcyM,2876
-mini_arcade_core/managers/cheats.py,sha256=2tVvEwLmSwyYfmyvTYcauyQ4ZUItwoeES0hG0KS99NQ,10265
-mini_arcade_core/managers/entities.py,sha256=mBgSFgdZ73f5ZZ-_GtvnqOFWuSySX5QJZrZ77sH4qes,831
-mini_arcade_core/managers/inputs.py,sha256=MZ1dTnVDTwvw6nOE3WIB0gUAnSfgIYzfjc68wEuTCpU,8414
-mini_arcade_core/managers/overlays.py,sha256=4DdBExRqoZgXYCDUkBJ_fw3EOpiJ2YqIqadKxS7Cwrg,1452
-mini_arcade_core/managers/system.py,sha256=_nFtHK1wH3xVdqhKco0UUEeUhloyCoHrgz6iDfEt4m4,611
-mini_arcade_core/scenes/__init__.py,sha256=4r8MuW64hJk3rIX5xQxz0FFw4VT2qUq40e0Ot-F_jl0,467
-mini_arcade_core/scenes/autoreg.py,sha256=b4V0jaA65I2hnT2f___rg_pT556OjrtoNjIRdZrXBaI,1009
-mini_arcade_core/scenes/model.py,sha256=ljNlyDf_DenwHuxXZCP5w-WxBg5jg3qtefoNdUulQEA,767
-mini_arcade_core/scenes/registry.py,sha256=0B3iSvepydwMpELQz8cRaQeAU0pR1Fz9O1YtWshLjQw,3226
-mini_arcade_core/scenes/runtime.py,sha256=O1Gc9JJlV3ko9clC4ta1jzJNT7yaQDQDmKuWHAaDkIQ,1096
-mini_arcade_core/scenes/scene.py,sha256=6oAK_RGsh23drKnQo3My88WMVAGC_Uqls7Gixc8iXN4,2911
-mini_arcade_core/scenes/system.py,sha256=clFLFAEVC_RADC9nklF4aT8LPIdovm0miZs5pMJHu2A,1558
-mini_arcade_core/spaces/__init__.py,sha256=i7J7UldFyXPsA98bycrDLarzL7QzwhHBhB3yVP4O_WA,203
-mini_arcade_core/spaces/d2/__init__.py,sha256=iWjm39RYDEshxSmiIWyGWa6Qr9O2gnHfOpzrl63FUro,626
-mini_arcade_core/spaces/d2/boundaries2d.py,sha256=H1HkCR1422MkQIEve2DFKvnav4RpvtLx-qTMxzmdDMQ,2610
-mini_arcade_core/spaces/d2/collision2d.py,sha256=jR5bOmqUaedxRzwFoKBgn7k-ozwklB4RP9pUTVk6aUw,1716
-mini_arcade_core/spaces/d2/geometry2d.py,sha256=js791mMpsE_YbEoqtTOsOxNSflvKgSk6VeVKhj9N318,1282
-mini_arcade_core/spaces/d2/kinematics2d.py,sha256=Lw6WcxpLlw3E-_ZW2iC1WdjSItTIu7K3tam7LuHBabI,2198
-mini_arcade_core/spaces/d2/physics2d.py,sha256=qIq86qWVuvcnLIMEPH6xx7XQO4tQhfiMZY6FseuVOR8,1636
-mini_arcade_core/ui/__init__.py,sha256=_10Z4FYhaPb6LkPaYwvzIj13D7Boy5pYEl7XS_Zfuto,424
-mini_arcade_core/ui/menu.py,sha256=xbpJ_Bf-C8eg2w2frTMCq1pjqMbS6q8G_gSSux4H5ro,18965
-mini_arcade_core/ui/overlays.py,sha256=4f9xJXFVg-NIRoCl1u0Jz4bnxR_C2FueIWPGpguNWc0,982
-mini_arcade_core-0.10.0.dist-info/METADATA,sha256=y9oy4yfi5k9z659kmUsDr_LCqLtz3NUCFbQ7xetJCEo,8189
-mini_arcade_core-0.10.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-mini_arcade_core-0.10.0.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
-mini_arcade_core-0.10.0.dist-info/RECORD,,