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

mini_arcade_core/spaces/d2/boundaries2d.py

@@ -39,25 +39,34 @@ class VerticalBounce:
 
     bounds: Bounds2D
 
-    def apply(self, obj: RectKinematic):
+    def apply(self, obj: RectKinematic) -> bool:
         """
         Apply vertical bounce to the given object.
 
         :param obj: The object to apply the bounce to.
         :type obj: RectKinematic
+
+        :return: True if a bounce occurred, False otherwise.
+        :rtype: bool
         """
         top = self.bounds.top
         bottom = self.bounds.bottom
 
+        bounced = False
+
         # Top collision
         if obj.position.y <= top:
             obj.position.y = top
             obj.velocity.vy *= -1
+            bounced = True
 
         # Bottom collision
         if obj.position.y + obj.size.height >= bottom:
             obj.position.y = bottom - obj.size.height
             obj.velocity.vy *= -1
+            bounced = True
+
+        return bounced
 
 
 class RectSprite(Protocol):

mini_arcade_core/spaces/d2/collision2d.py

@@ -4,45 +4,35 @@
 
 from __future__ import annotations
 
+from abc import ABC, abstractmethod
 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:
+class Collider2D(ABC):
+    """
+    Abstract base class for 2D colliders.
     """
-    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
+    position: Position2D
+    size: Size2D
 
-    :param pos_b: Top-left position of rectangle B.
-    :type pos_b: Position2D
+    @abstractmethod
+    def intersects(self, other: Collider2D) -> bool:
+        """
+        Check if this collider intersects with another collider.
 
-    :param size_b: Size of rectangle B.
-    :type size_b: Size2D
+        :param other: The other collider to check against.
+        :type other: Collider2D
 
-    :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
-    )
+        :return: True if the colliders intersect.
+        :rtype: bool
+        """
 
 
 @dataclass
-class RectCollider:
+class RectCollider(Collider2D):
     """
     OOP collision helper that wraps a Position2D + Size2D pair.
 
@@ -66,6 +56,13 @@ class RectCollider:
         :return: True if the rectangles intersect.
         :rtype: bool
         """
-        return _rects_intersect(
-            self.position, self.size, other.position, other.size
+        pos_a = self.position
+        size_a = self.size
+        pos_b = other.position
+        size_b = other.size
+        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
         )

mini_arcade_core/spaces/d2/geometry2d.py

@@ -19,6 +19,15 @@ class Position2D:
     x: float
     y: float
 
+    def to_tuple(self) -> tuple[float, float]:
+        """
+        Convert Position2D to a tuple.
+
+        :return: Tuple of (x, y).
+        :rtype: tuple[float, float]
+        """
+        return (self.x, self.y)
+
 
 @dataclass
 class Size2D:
@@ -32,6 +41,15 @@ class Size2D:
     width: int
     height: int
 
+    def to_tuple(self) -> tuple[int, int]:
+        """
+        Convert Size2D to a tuple.
+
+        :return: Tuple of (width, height).
+        :rtype: tuple[int, int]
+        """
+        return (self.width, self.height)
+
 
 @dataclass
 class Bounds2D:

mini_arcade_core/spaces/d2/kinematics2d.py

@@ -7,8 +7,7 @@ from __future__ import annotations
 from dataclasses import dataclass
 from typing import Optional
 
-from mini_arcade_core.backend import Color
-
+from .collision2d import Collider2D
 from .geometry2d import Position2D, Size2D
 from .physics2d import Velocity2D
 
@@ -28,7 +27,7 @@ class KinematicData:
     size: Size2D
     velocity: Velocity2D
     time_scale: float = 1.0
-    color: Optional[Color] = None  # future use
+    collider: Optional[Collider2D] = None
 
     # Justification: Convenience factory with many params.
     # pylint: disable=too-many-arguments,too-many-positional-arguments
@@ -42,7 +41,6 @@ class KinematicData:
         vx: float = 0.0,
         vy: float = 0.0,
         time_scale: float = 1.0,
-        color: Optional[Color] = None,
     ) -> "KinematicData":
         """
         Convenience factory for rectangular kinematic data.
@@ -65,9 +63,6 @@ class KinematicData:
         :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
         """
@@ -76,7 +71,6 @@ class KinematicData:
             size=Size2D(int(width), int(height)),
             velocity=Velocity2D(float(vx), float(vy)),
             time_scale=time_scale,
-            color=color,
         )
 
     # pylint: enable=too-many-arguments,too-many-positional-arguments

mini_arcade_core/spaces/d2/physics2d.py

@@ -19,6 +19,15 @@ class Velocity2D:
     vx: float = 0.0
     vy: float = 0.0
 
+    def to_tuple(self) -> tuple[float, float]:
+        """
+        Convert Velocity2D to a tuple.
+
+        :return: Tuple of (vx, vy).
+        :rtype: tuple[float, float]
+        """
+        return (self.vx, self.vy)
+
     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

mini_arcade_core/ui/__init__.py

@@ -1,26 +0,0 @@
-"""
-UI utilities and components for Mini Arcade Core.
-Includes buttons, labels, and layout management.
-"""
-
-from __future__ import annotations
-
-from .menu import (
-    BaseMenuScene,
-    Menu,
-    MenuItem,
-    MenuModel,
-    MenuStyle,
-    MenuSystem,
-)
-from .overlays import BaseOverlay
-
-__all__ = [
-    "Menu",
-    "MenuItem",
-    "MenuStyle",
-    "MenuModel",
-    "MenuSystem",
-    "BaseMenuScene",
-    "BaseOverlay",
-]