mini-arcade-core 0.7.4__py3-none-any.whl → 0.8.0__py3-none-any.whl

mini_arcade_core/__init__.py

@@ -9,8 +9,18 @@ import logging
 from importlib.metadata import PackageNotFoundError, version
 
 from .backend import Backend, Event, EventType
-from .entity import Entity, SpriteEntity
+from .boundaries2d import (
+    RectKinematic,
+    RectSprite,
+    VerticalBounce,
+    VerticalWrap,
+)
+from .collision2d import RectCollider
+from .entity import Entity, KinematicEntity, SpriteEntity
 from .game import Game, GameConfig
+from .geometry2d import Bounds2D, Position2D, Size2D
+from .kinematics2d import KinematicData
+from .physics2d import Velocity2D
 from .scene import Scene
 
 logger = logging.getLogger(__name__)
@@ -25,8 +35,15 @@ def run_game(initial_scene_cls: type[Scene], config: GameConfig | None = None):
 
     :param config: Optional GameConfig to customize game settings.
     :type config: GameConfig | None
+
+    :raises ValueError: If the provided config does not have a valid Backend.
     """
-    game = Game(config or GameConfig())
+    cfg = config or GameConfig()
+    if config.backend is None:
+        raise ValueError(
+            "GameConfig.backend must be set to a Backend instance"
+        )
+    game = Game(cfg)
     scene = initial_scene_cls(game)
     game.run(scene)
 
@@ -41,6 +58,17 @@ __all__ = [
     "Backend",
     "Event",
     "EventType",
+    "Velocity2D",
+    "Position2D",
+    "Size2D",
+    "KinematicEntity",
+    "KinematicData",
+    "RectCollider",
+    "VerticalBounce",
+    "Bounds2D",
+    "VerticalWrap",
+    "RectSprite",
+    "RectKinematic",
 ]
 
 PACKAGE_NAME = "mini-arcade-core"  # or whatever is in your pyproject.toml

mini_arcade_core/backend.py

@@ -7,7 +7,9 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum, auto
-from typing import Iterable, Protocol
+from typing import Iterable, Protocol, Tuple, Union
+
+Color = Union[Tuple[int, int, int], Tuple[int, int, int, int]]
 
 
 class EventType(Enum):
@@ -50,7 +52,7 @@ class Backend(Protocol):
     mini-arcade-core only talks to this protocol, never to SDL/pygame directly.
     """
 
-    def init(self, width: int, height: int, title: str) -> None:
+    def init(self, width: int, height: int, title: str):
         """
         Initialize the backend and open a window.
         Should be called once before the main loop.
@@ -74,7 +76,7 @@ class Backend(Protocol):
         :rtype: Iterable[Event]
         """
 
-    def set_clear_color(self, r: int, g: int, b: int) -> None:
+    def set_clear_color(self, r: int, g: int, b: int):
         """
         Set the background/clear color used by begin_frame.
 
@@ -88,12 +90,12 @@ class Backend(Protocol):
         :type b: int
         """
 
-    def begin_frame(self) -> None:
+    def begin_frame(self):
         """
         Prepare for drawing a new frame (e.g. clear screen).
         """
 
-    def end_frame(self) -> None:
+    def end_frame(self):
         """
         Present the frame to the user (swap buffers).
         """
@@ -106,8 +108,8 @@ class Backend(Protocol):
         y: int,
         w: int,
         h: int,
-        color: tuple[int, int, int] = (255, 255, 255),
-    ) -> None:
+        color: Color = (255, 255, 255),
+    ):
         """
         Draw a filled rectangle in some default color.
         We'll keep this minimal for now; later we can extend with colors/sprites.
@@ -125,7 +127,7 @@ class Backend(Protocol):
         :type h: int
 
         :param color: RGB color tuple.
-        :type color: tuple[int, int, int]
+        :type color: Color
         """
 
     # pylint: enable=too-many-arguments,too-many-positional-arguments
@@ -135,8 +137,8 @@ class Backend(Protocol):
         x: int,
         y: int,
         text: str,
-        color: tuple[int, int, int] = (255, 255, 255),
-    ) -> None:
+        color: Color = (255, 255, 255),
+    ):
         """
         Draw text at the given position in a default font and color.
 
@@ -153,7 +155,7 @@ class Backend(Protocol):
         :type text: str
 
         :param color: RGB color tuple.
-        :type color: tuple[int, int, int]
+        :type color: Color
         """
 
     def capture_frame(self, path: str | None = None) -> bytes | None:

mini_arcade_core/boundaries2d.py

@@ -0,0 +1,107 @@
+"""
+Boundary behaviors for 2D rectangular objects.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Protocol
+
+from .geometry2d import Bounds2D, Position2D, Size2D
+from .physics2d import Velocity2D
+
+
+class RectKinematic(Protocol):
+    """
+    Minimal contract for something that can bounce:
+    - position: Position2D
+    - size: Size2D
+    - velocity: Velocity2D
+
+    :ivar position (Position2D): Top-left position of the object.
+    :ivar size (Size2D): Size of the object.
+    :ivar velocity (Velocity2D): Velocity of the object.
+    """
+
+    position: Position2D
+    size: Size2D
+    velocity: Velocity2D
+
+
+@dataclass
+class VerticalBounce:
+    """
+    Bounce an object off the top/bottom bounds by inverting vy
+    and clamping its position inside the bounds.
+
+    :ivar bounds (Bounds2D): The boundary rectangle.
+    """
+
+    bounds: Bounds2D
+
+    def apply(self, obj: RectKinematic):
+        """
+        Apply vertical bounce to the given object.
+
+        :param obj: The object to apply the bounce to.
+        :type obj: RectKinematic
+        """
+        top = self.bounds.top
+        bottom = self.bounds.bottom
+
+        # Top collision
+        if obj.position.y <= top:
+            obj.position.y = top
+            obj.velocity.vy *= -1
+
+        # Bottom collision
+        if obj.position.y + obj.size.height >= bottom:
+            obj.position.y = bottom - obj.size.height
+            obj.velocity.vy *= -1
+
+
+class RectSprite(Protocol):
+    """
+    Minimal contract for something that can wrap:
+    - position: Position2D
+    - size: Size2D
+    (no velocity required)
+
+    :ivar position (Position2D): Top-left position of the object.
+    :ivar size (Size2D): Size of the object.
+    """
+
+    position: Position2D
+    size: Size2D
+
+
+@dataclass
+class VerticalWrap:
+    """
+    Wrap an object top <-> bottom.
+
+    If it leaves above the top, it reappears at the bottom.
+    If it leaves below the bottom, it reappears at the top.
+
+    :ivar bounds (Bounds2D): The boundary rectangle.
+    """
+
+    bounds: Bounds2D
+
+    def apply(self, obj: RectSprite):
+        """
+        Apply vertical wrap to the given object.
+
+        :param obj: The object to apply the wrap to.
+        :type obj: RectSprite
+        """
+        top = self.bounds.top
+        bottom = self.bounds.bottom
+
+        # Completely above top → appear at bottom
+        if obj.position.y + obj.size.height < top:
+            obj.position.y = bottom
+
+        # Completely below bottom → appear at top
+        elif obj.position.y > bottom:
+            obj.position.y = top - obj.size.height

mini_arcade_core/collision2d.py

@@ -0,0 +1,71 @@
+"""
+2D collision detection helpers.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+from .geometry2d import Position2D, Size2D
+
+
+def _rects_intersect(
+    pos_a: Position2D,
+    size_a: Size2D,
+    pos_b: Position2D,
+    size_b: Size2D,
+) -> bool:
+    """
+    Low-level AABB check. Internal helper.
+
+    :param pos_a: Top-left position of rectangle A.
+    :type pos_a: Position2D
+
+    :param size_a: Size of rectangle A.
+    :type size_a: Size2D
+
+    :param pos_b: Top-left position of rectangle B.
+    :type pos_b: Position2D
+
+    :param size_b: Size of rectangle B.
+    :type size_b: Size2D
+
+    :return: True if the rectangles intersect.
+    :rtype: bool
+    """
+    return not (
+        pos_a.x + size_a.width < pos_b.x
+        or pos_a.x > pos_b.x + size_b.width
+        or pos_a.y + size_a.height < pos_b.y
+        or pos_a.y > pos_b.y + size_b.height
+    )
+
+
+@dataclass
+class RectCollider:
+    """
+    OOP collision helper that wraps a Position2D + Size2D pair.
+
+    It does NOT own the data – it just points to them. If the
+    entity moves (position changes), the collider “sees” it.
+
+    :ivar position (Position2D): Top-left position of the rectangle.
+    :ivar size (Size2D): Size of the rectangle.
+    """
+
+    position: Position2D
+    size: Size2D
+
+    def intersects(self, other: "RectCollider") -> bool:
+        """
+        High-level OOP method to check collision with another collider.
+
+        ;param other: The other rectangle collider.
+        :type other: RectCollider
+
+        :return: True if the rectangles intersect.
+        :rtype: bool
+        """
+        return _rects_intersect(
+            self.position, self.size, other.position, other.size
+        )

mini_arcade_core/entity.py

@@ -6,6 +6,10 @@ from __future__ import annotations
 
 from typing import Any
 
+from .collision2d import RectCollider
+from .geometry2d import Position2D, Size2D
+from .kinematics2d import KinematicData
+
 
 class Entity:
     """Entity base class for game objects."""
@@ -30,22 +34,35 @@ class Entity:
 class SpriteEntity(Entity):
     """Entity with position and size."""
 
-    def __init__(self, x: float, y: float, width: int, height: int):
+    def __init__(self, position: Position2D, size: Size2D):
+        """
+        :param position: Top-left position of the entity.
+        :type position: Position2D
+
+        :param size: Size of the entity.
+        :type size: Size2D
         """
-        :param x: X position.
-        :type x: float
+        self.position = Position2D(float(position.x), float(position.y))
+        self.size = Size2D(int(size.width), int(size.height))
+        self.collider = RectCollider(self.position, self.size)
 
-        :param y: Y position.
-        :type y: float
 
-        :param width: Width of the entity.
-        :type width: int
+class KinematicEntity(SpriteEntity):
+    """SpriteEntity with velocity-based movement."""
 
-        :param height: Height of the entity.
-        :type height: int
+    def __init__(self, kinematic_data: KinematicData):
+        """
+        :param kinematic_data: Kinematic data for the entity.
+        :type kinematic_data: KinematicData
         """
-        self.x = x
-        self.y = y
-        self.width = width
-        self.height = height
-        # TODO: velocity, color, etc.
+        super().__init__(
+            position=kinematic_data.position,
+            size=kinematic_data.size,
+        )
+
+        self.velocity = kinematic_data.velocity
+
+    def update(self, dt: float):
+        self.position.x, self.position.y = self.velocity.advance(
+            self.position.x, self.position.y, dt
+        )

mini_arcade_core/game.py

@@ -29,7 +29,7 @@ class GameConfig:
     :ivar title: Title of the game window.
     :ivar fps: Target frames per second.
     :ivar background_color: RGB background color.
-    :ivar backend: Optional backend class to use for rendering and input.
+    :ivar backend: Optional Backend instance to use for rendering and input.
     """
 
     width: int = 800
@@ -47,11 +47,12 @@ class Game:
         """
         :param config: Game configuration options.
         :type config: GameConfig
+
+        :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
-        self.backend: Backend | None = config.backend
 
         if config.backend is None:
             raise ValueError(
@@ -140,8 +141,11 @@ class Game:
             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"

mini_arcade_core/geometry2d.py

@@ -0,0 +1,69 @@
+"""
+2D geometry data structures.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Position2D:
+    """
+    Simple 2D position.
+
+    :ivar x (float): X coordinate.
+    :ivar y (float): Y coordinate.
+    """
+
+    x: float
+    y: float
+
+
+@dataclass
+class Size2D:
+    """
+    Simple 2D size.
+
+    :ivar width (int): Width.
+    :ivar height (int): Height.
+    """
+
+    width: int
+    height: int
+
+
+@dataclass
+class Bounds2D:
+    """
+    Axis-aligned rectangular bounds in world space.
+    (left, top) .. (right, bottom)
+
+    :ivar left (float): Left boundary.
+    :ivar top (float): Top boundary.
+    :ivar right (float): Right boundary.
+    :ivar bottom (float): Bottom boundary.
+    """
+
+    left: float
+    top: float
+    right: float
+    bottom: float
+
+    @classmethod
+    def from_size(cls, size: "Size2D") -> "Bounds2D":
+        """
+        Convenience factory for screen/world bounds starting at (0, 0).
+
+        :param size: Size2D defining the bounds.
+        :type size: Size2D
+
+        :return: Bounds2D from (0,0) to (size.width, size.height).
+        :rtype: Bounds2D
+        """
+        return cls(
+            left=0.0,
+            top=0.0,
+            right=float(size.width),
+            bottom=float(size.height),
+        )

mini_arcade_core/kinematics2d.py

@@ -0,0 +1,78 @@
+"""
+Kinematic helpers for mini_arcade_core (position + size + velocity).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from .backend import Color
+from .geometry2d import Position2D, Size2D
+from .physics2d import Velocity2D
+
+
+@dataclass
+class KinematicData:
+    """
+    Simple data structure to hold position, size, and velocity.
+
+    :ivar position (Position2D): Top-left position of the object.
+    :ivar size (Size2D): Size of the object.
+    :ivar velocity (Velocity2D): Velocity of the object.
+    :ivar color (Optional[Color]): Optional color for rendering.
+    """
+
+    position: Position2D
+    size: Size2D
+    velocity: Velocity2D
+    color: Optional[Color] = None  # future use
+
+    # Justification: Convenience factory with many params.
+    # pylint: disable=too-many-arguments,too-many-positional-arguments
+    @classmethod
+    def rect(
+        cls,
+        x: float,
+        y: float,
+        width: int,
+        height: int,
+        vx: float = 0.0,
+        vy: float = 0.0,
+        color: Optional[Color] = None,
+    ) -> "KinematicData":
+        """
+        Convenience factory for rectangular kinematic data.
+
+        :param x: Top-left X position.
+        :type x: float
+
+        :param y: Top-left Y position.
+        :type y: float
+
+        :param width: Width of the object.
+        :type width: int
+
+        :param height: Height of the object.
+        :type height: int
+
+        :param vx: Velocity in the X direction.
+        :type vx: float
+
+        :param vy: Velocity in the Y direction.
+        :type vy: float
+
+        :param color: Optional color for rendering.
+        :type color: Optional[Color]
+
+        :return: KinematicData instance with the specified parameters.
+        :rtype: KinematicData
+        """
+        return cls(
+            position=Position2D(float(x), float(y)),
+            size=Size2D(int(width), int(height)),
+            velocity=Velocity2D(float(vx), float(vy)),
+            color=color,
+        )
+
+    # pylint: enable=too-many-arguments,too-many-positional-arguments

mini_arcade_core/physics2d.py

@@ -0,0 +1,73 @@
+"""
+Simple 2D physics utilities.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Velocity2D:
+    """
+    Simple 2D velocity vector.
+
+    :ivar vx (float): Velocity in the X direction.
+    :ivar vy (float): Velocity in the Y direction.
+    """
+
+    vx: float = 0.0
+    vy: float = 0.0
+
+    def advance(self, x: float, y: float, dt: float) -> tuple[float, float]:
+        """Return new (x, y) after dt seconds."""
+        return x + self.vx * dt, y + self.vy * dt
+
+    def stop(self):
+        """Stop movement in both axes."""
+        self.vx = 0.0
+        self.vy = 0.0
+
+    def stop_x(self):
+        """Stop horizontal movement."""
+        self.vx = 0.0
+
+    def stop_y(self):
+        """Stop vertical movement."""
+        self.vy = 0.0
+
+    def move_up(self, speed: float):
+        """
+        Set vertical velocity upwards (negative Y).
+
+        :param speed: Speed to set.
+        :type speed: float
+        """
+        self.vy = -abs(speed)
+
+    def move_down(self, speed: float):
+        """
+        Set vertical velocity downwards (positive Y).
+
+        :param speed: Speed to set.
+        :type speed: float
+        """
+        self.vy = abs(speed)
+
+    def move_left(self, speed: float):
+        """
+        Set horizontal velocity to the left (negative X)."
+
+        :param speed: Speed to set.
+        :type speed: float
+        """
+        self.vx = -abs(speed)
+
+    def move_right(self, speed: float):
+        """
+        Set horizontal velocity to the right (positive X).
+
+        :param speed: Speed to set.
+        :type speed: float
+        """
+        self.vx = abs(speed)

mini_arcade_core/scene.py

@@ -7,9 +7,10 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import Callable, List
 
-from mini_arcade_core.backend import Backend
-
+from .backend import Backend, Event
+from .entity import Entity
 from .game import Game
+from .geometry2d import Size2D
 
 OverlayFunc = Callable[[Backend], None]
 
@@ -23,10 +24,55 @@ class Scene(ABC):
         :type game: Game
         """
         self.game = game
+        self.entities: List[Entity] = []
+        self.size: Size2D = Size2D(game.config.width, game.config.height)
         # overlays drawn on top of the scene
         self._overlays: List[OverlayFunc] = []
 
-    def add_overlay(self, overlay: OverlayFunc) -> None:
+    def add_entity(self, *entities: Entity):
+        """
+        Register one or more entities in this scene.
+
+        :param entities: One or more Entity instances to add.
+        :type entities: Entity
+        """
+        self.entities.extend(entities)
+
+    def remove_entity(self, entity: Entity):
+        """
+        Unregister a single entity, if present.
+
+        :param entity: The Entity instance to remove.
+        :type entity: Entity
+        """
+        if entity in self.entities:
+            self.entities.remove(entity)
+
+    def clear_entities(self):
+        """Remove all entities from the scene."""
+        self.entities.clear()
+
+    def update_entities(self, dt: float):
+        """
+        Default update loop for all entities.
+
+        :param dt: Time delta in seconds.
+        :type dt: float
+        """
+        for ent in self.entities:
+            ent.update(dt)
+
+    def draw_entities(self, surface: Backend):
+        """
+        Default draw loop for all entities.
+
+        :param surface: The backend surface to draw on.
+        :type surface: Backend
+        """
+        for ent in self.entities:
+            ent.draw(surface)
+
+    def add_overlay(self, overlay: OverlayFunc):
         """
         Register an overlay (drawn every frame, after entities).
 
@@ -35,7 +81,7 @@ class Scene(ABC):
         """
         self._overlays.append(overlay)
 
-    def remove_overlay(self, overlay: OverlayFunc) -> None:
+    def remove_overlay(self, overlay: OverlayFunc):
         """
         Unregister a previously added overlay.
 
@@ -45,11 +91,11 @@ class Scene(ABC):
         if overlay in self._overlays:
             self._overlays.remove(overlay)
 
-    def clear_overlays(self) -> None:
+    def clear_overlays(self):
         """Clear all registered overlays."""
         self._overlays.clear()
 
-    def draw_overlays(self, surface: Backend) -> None:
+    def draw_overlays(self, surface: Backend):
         """
         Call all overlays. Scenes should call this at the end of draw().
 
@@ -68,12 +114,12 @@ class Scene(ABC):
         """Called when the scene is replaced."""
 
     @abstractmethod
-    def handle_event(self, event: object):
+    def handle_event(self, event: Event):
         """
         Handle input / events (e.g. pygame.Event).
 
         :param event: The event to handle.
-        :type event: object
+        :type event: Event
         """
 
     @abstractmethod
@@ -86,10 +132,10 @@ class Scene(ABC):
         """
 
     @abstractmethod
-    def draw(self, surface: object):
+    def draw(self, surface: Backend):
         """
         Render to the main surface.
 
         :param surface: The backend surface to draw on.
-        :type surface: object
+        :type surface: Backend
         """

{mini_arcade_core-0.7.4.dist-info → mini_arcade_core-0.8.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mini-arcade-core
-Version: 0.7.4
+Version: 0.8.0
 Summary: Tiny scene-based game loop core for small arcade games.
 License: Copyright (c) 2025 Santiago Rincón
            
@@ -123,21 +123,21 @@ Represents one state of your game (menu, gameplay, pause, etc.):
 from mini_arcade_core import Scene, Game
 
 class MyScene(Scene):
-    def on_enter(self) -> None:
+    def on_enter(self):
         print("Scene entered")
 
-    def on_exit(self) -> None:
+    def on_exit(self):
         print("Scene exited")
 
-    def handle_event(self, event: object) -> None:
+    def handle_event(self, event: object):
         # Handle input / events from your backend
         pass
 
-    def update(self, dt: float) -> None:
+    def update(self, dt: float):
         # Game logic
         pass
 
-    def draw(self, surface: object) -> None:
+    def draw(self, surface: object):
         # Rendering via your backend
         pass
 ```
@@ -150,17 +150,17 @@ Lightweight game object primitives:
 from mini_arcade_core import Entity, SpriteEntity
 
 class Ball(Entity):
-    def __init__(self) -> None:
+    def __init__(self):
         self.x = 100.0
         self.y = 100.0
         self.vx = 200.0
         self.vy = 150.0
 
-    def update(self, dt: float) -> None:
+    def update(self, dt: float):
         self.x += self.vx * dt
         self.y += self.vy * dt
 
-    def draw(self, surface: object) -> None:
+    def draw(self, surface: object):
         # Use your backend to draw the ball on `surface`
         pass
 
@@ -182,7 +182,7 @@ from mini_arcade_core import Game, GameConfig, Scene
 
 
 class PygameGame(Game):
-    def __init__(self, config: GameConfig) -> None:
+    def __init__(self, config: GameConfig):
         super().__init__(config)
         pygame.init()
         self._screen = pygame.display.set_mode(
@@ -191,13 +191,13 @@ class PygameGame(Game):
         pygame.display.set_caption(config.title)
         self._clock = pygame.time.Clock()
 
-    def change_scene(self, scene: Scene) -> None:
+    def change_scene(self, scene: Scene):
         if self._current_scene is not None:
             self._current_scene.on_exit()
         self._current_scene = scene
         self._current_scene.on_enter()
 
-    def run(self, initial_scene: Scene) -> None:
+    def run(self, initial_scene: Scene):
         self.change_scene(initial_scene)
         self._running = True
 
@@ -220,7 +220,7 @@ class PygameGame(Game):
 
 
 class PongScene(Scene):
-    def __init__(self, game: Game) -> None:
+    def __init__(self, game: Game):
         super().__init__(game)
         self.x = 100.0
         self.y = 100.0
@@ -228,17 +228,17 @@ class PongScene(Scene):
         self.vy = 150.0
         self.radius = 10
 
-    def on_enter(self) -> None:
+    def on_enter(self):
         print("Pong started")
 
-    def on_exit(self) -> None:
+    def on_exit(self):
         print("Pong finished")
 
-    def handle_event(self, event: object) -> None:
+    def handle_event(self, event: object):
         # no input yet
         pass
 
-    def update(self, dt: float) -> None:
+    def update(self, dt: float):
         self.x += self.vx * dt
         self.y += self.vy * dt
 
@@ -250,7 +250,7 @@ class PongScene(Scene):
         if self.y < self.radius or self.y > height - self.radius:
             self.vy *= -1
 
-    def draw(self, surface: pygame.Surface) -> None:  # type: ignore[override]
+    def draw(self, surface: pygame.Surface):  # type: ignore[override]
         pygame.draw.circle(
             surface, (255, 255, 255), (int(self.x), int(self.y)), self.radius
         )

mini_arcade_core-0.8.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+mini_arcade_core/__init__.py,sha256=2PBNxk-rxjJxPvF6PvpdJ_rat0knyo6a-VRI8sROofI,2554
+mini_arcade_core/backend.py,sha256=4PYuE_hhvLgg6acPa3JlIKCqPcYc8qJv2gIFvwRI_W8,4484
+mini_arcade_core/boundaries2d.py,sha256=H1HkCR1422MkQIEve2DFKvnav4RpvtLx-qTMxzmdDMQ,2610
+mini_arcade_core/collision2d.py,sha256=iq800wsoYQNft3SA-W4jeY1wXhbpz2E7IkIorZBI238,1718
+mini_arcade_core/entity.py,sha256=1AuE-_iMJYHxSyG783fsyByKK8Gx4vWWKMCEPjtgHXw,1776
+mini_arcade_core/game.py,sha256=DM3pbALCihTKfhPgKSftqOYXVEmMdiy-qvnk6hA4tvE,5278
+mini_arcade_core/geometry2d.py,sha256=js791mMpsE_YbEoqtTOsOxNSflvKgSk6VeVKhj9N318,1282
+mini_arcade_core/kinematics2d.py,sha256=twBx-1jEwdknIJEyYBUg4VZyAvw1d7pGHaGFd36TPbo,2085
+mini_arcade_core/physics2d.py,sha256=qIq86qWVuvcnLIMEPH6xx7XQO4tQhfiMZY6FseuVOR8,1636
+mini_arcade_core/scene.py,sha256=OBfDe3JJt598itj2qtsChvacQM9i8o_g9TRznWw4_z0,3721
+mini_arcade_core-0.8.0.dist-info/METADATA,sha256=pjaAUFvFK5665leA2g3lmTgDNoN06nVQlRtx14dgO0I,8188
+mini_arcade_core-0.8.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+mini_arcade_core-0.8.0.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
+mini_arcade_core-0.8.0.dist-info/RECORD,,

mini_arcade_core-0.7.4.dist-info/RECORD

@@ -1,9 +0,0 @@
-mini_arcade_core/__init__.py,sha256=0gkloHYTV8FmEZbBLxNNy-eJge2y7pkQ_PCcrfeJ3uo,1831
-mini_arcade_core/backend.py,sha256=SvsHDO0Fq86buTqMkOCSAidx2E4QAJ6mLsSa9ZQXEqY,4514
-mini_arcade_core/entity.py,sha256=mAkedH0j14giBQFRpQjaym46uczbQDln6nbxy0WFAqU,1077
-mini_arcade_core/game.py,sha256=qfJ4UiAA2Mu-iAkj5SvxWxteGO9-s79IjlJk9ORHliw,5077
-mini_arcade_core/scene.py,sha256=QENcn2hWUF3Ja9pU8NK67NYmC8ptnjdpUkg1qsUEl60,2435
-mini_arcade_core-0.7.4.dist-info/METADATA,sha256=3-lnmTd16f89QKre5WegNgd8xQ2fR4MoY5ZrCB1A2n4,8324
-mini_arcade_core-0.7.4.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-mini_arcade_core-0.7.4.dist-info/licenses/LICENSE,sha256=3lHAuV0584cVS5vAqi2uC6GcsVgxUijvwvtZckyvaZ4,1096
-mini_arcade_core-0.7.4.dist-info/RECORD,,