kraken-engine 1.2.1__cp313-cp313-macosx_11_0_arm64.whl

pykraken/_core/collision.pyi

@@ -0,0 +1,283 @@
+"""
+Collision detection functions
+"""
+from __future__ import annotations
+import pykraken._core
+import typing
+__all__: list[str] = ['contains', 'overlap']
+@typing.overload
+def contains(outer: pykraken._core.Rect, inner: pykraken._core.Rect) -> bool:
+    """
+    Checks if one rectangle completely contains another rectangle.
+    
+    Parameters:
+        outer (Rect): The outer rectangle.
+        inner (Rect): The inner rectangle.
+    
+    Returns:
+        bool: Whether the outer rectangle completely contains the inner rectangle.
+    """
+@typing.overload
+def contains(rect: pykraken._core.Rect, circle: pykraken._core.Circle) -> bool:
+    """
+    Checks if a rectangle completely contains a circle.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: Whether the rectangle completely contains the circle.
+    """
+@typing.overload
+def contains(rect: pykraken._core.Rect, line: pykraken._core.Line) -> bool:
+    """
+    Checks if a rectangle completely contains a line.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        line (Line): The line.
+    
+    Returns:
+        bool: Whether the rectangle completely contains the line.
+    """
+@typing.overload
+def contains(outer: pykraken._core.Circle, inner: pykraken._core.Circle) -> bool:
+    """
+    Checks if one circle completely contains another circle.
+    
+    Parameters:
+        outer (Circle): The outer circle.
+        inner (Circle): The inner circle.
+    
+    Returns:
+        bool: Whether the outer circle completely contains the inner circle.
+    """
+@typing.overload
+def contains(circle: pykraken._core.Circle, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a circle completely contains a rectangle.
+    
+    Parameters:
+        circle (Circle): The circle.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the circle completely contains the rectangle.
+    """
+@typing.overload
+def contains(circle: pykraken._core.Circle, line: pykraken._core.Line) -> bool:
+    """
+    Checks if a circle completely contains a line.
+    
+    Parameters:
+        circle (Circle): The circle.
+        line (Line): The line.
+    
+    Returns:
+        bool: Whether the circle completely contains the line.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Rect, b: pykraken._core.Rect) -> bool:
+    """
+    Checks if two rectangles overlap.
+    
+    Parameters:
+        a (Rect): The first rectangle.
+        b (Rect): The second rectangle.
+    
+    Returns:
+        bool: Whether the rectangles overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, circle: pykraken._core.Circle) -> bool:
+    """
+    Checks if a rectangle and a circle overlap.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: Whether the rectangle and circle overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, line: pykraken._core.Line) -> bool:
+    """
+    Checks if a rectangle and a line overlap.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        line (Line): The line.
+    
+    Returns:
+        bool: Whether the rectangle and line overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, point: pykraken._core.Vec2) -> bool:
+    """
+    Checks if a rectangle contains a point.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        point (Vec2): The point.
+    
+    Returns:
+        bool: Whether the rectangle contains the point.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Circle, b: pykraken._core.Circle) -> bool:
+    """
+    Checks if two circles overlap.
+    
+    Parameters:
+        a (Circle): The first circle.
+        b (Circle): The second circle.
+    
+    Returns:
+        bool: Whether the circles overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a circle and a rectangle overlap.
+    
+    Parameters:
+        circle (Circle): The circle.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the circle and rectangle overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, line: pykraken._core.Line) -> bool:
+    """
+    Checks if a circle and a line overlap.
+    
+    Parameters:
+        circle (Circle): The circle.
+        line (Line): The line.
+    
+    Returns:
+        bool: Whether the circle and line overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, point: pykraken._core.Vec2) -> bool:
+    """
+    Checks if a circle contains a point.
+    
+    Parameters:
+        circle (Circle): The circle.
+        point (Vec2): The point.
+    
+    Returns:
+        bool: Whether the circle contains the point.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Line, b: pykraken._core.Line) -> bool:
+    """
+    Checks if two lines overlap (intersect).
+    
+    Parameters:
+        a (Line): The first line.
+        b (Line): The second line.
+    
+    Returns:
+        bool: Whether the lines intersect.
+    """
+@typing.overload
+def overlap(line: pykraken._core.Line, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a line and a rectangle overlap.
+    
+    Parameters:
+        line (Line): The line.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the line and rectangle overlap.
+    """
+@typing.overload
+def overlap(line: pykraken._core.Line, circle: pykraken._core.Circle) -> bool:
+    """
+    Checks if a line and a circle overlap.
+    
+    Parameters:
+        line (Line): The line.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: Whether the line and circle overlap.
+    """
+@typing.overload
+def overlap(point: pykraken._core.Vec2, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a point is inside a rectangle.
+    
+    Parameters:
+        point (Vec2): The point.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the point is inside the rectangle.
+    """
+@typing.overload
+def overlap(point: pykraken._core.Vec2, circle: pykraken._core.Circle) -> bool:
+    """
+    Checks if a point is inside a circle.
+    
+    Parameters:
+        point (Vec2): The point.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: Whether the point is inside the circle.
+    """
+@typing.overload
+def overlap(polygon: pykraken._core.Polygon, point: pykraken._core.Vec2) -> bool:
+    """
+    Checks if a polygon contains a point.
+    
+    Parameters:
+        polygon (Polygon): The polygon.
+        point (Vec2): The point.
+    
+    Returns:
+        bool: Whether the polygon contains the point.
+    """
+@typing.overload
+def overlap(point: pykraken._core.Vec2, polygon: pykraken._core.Polygon) -> bool:
+    """
+    Checks if a point is inside a polygon.
+    
+    Parameters:
+        point (Vec2): The point.
+        polygon (Polygon): The polygon.
+    
+    Returns:
+        bool: Whether the point is inside the polygon.
+    """
+@typing.overload
+def overlap(polygon: pykraken._core.Polygon, rect: pykraken._core.Rect) -> bool:
+    """
+    Checks if a polygon and a rectangle overlap.
+    
+    Parameters:
+        polygon (Polygon): The polygon.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: Whether the polygon and rectangle overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, polygon: pykraken._core.Polygon) -> bool:
+    """
+    Checks if a rectangle and a polygon overlap.
+    
+    Parameters:
+        rect (Rect): The rectangle.
+        polygon (Polygon): The polygon.
+    
+    Returns:
+        bool: Whether the rectangle and polygon overlap.
+    """

pykraken/_core/color.pyi

@@ -0,0 +1,113 @@
+"""
+
+Color utility functions and predefined color constants.
+
+This module provides functions for color manipulation and conversion,
+as well as commonly used color constants for convenience.
+    
+"""
+from __future__ import annotations
+import pykraken._core
+import typing
+__all__: list[str] = ['BLACK', 'BLUE', 'BROWN', 'CYAN', 'DARK_GRAY', 'DARK_GREY', 'GRAY', 'GREEN', 'GREY', 'LIGHT_GRAY', 'LIGHT_GREY', 'MAGENTA', 'MAROON', 'NAVY', 'OLIVE', 'ORANGE', 'PINK', 'PURPLE', 'RED', 'TEAL', 'WHITE', 'YELLOW', 'from_hex', 'from_hsv', 'grayscale', 'invert', 'lerp']
+def from_hex(hex: str) -> pykraken._core.Color:
+    """
+    Create a Color from a hex string.
+    
+    Supports multiple hex formats:
+    - "#RRGGBB" - 6-digit hex with full opacity
+    - "#RRGGBBAA" - 8-digit hex with alpha
+    - "#RGB" - 3-digit hex (each digit duplicated)
+    - "#RGBA" - 4-digit hex with alpha (each digit duplicated)
+    
+    Args:
+        hex (str): Hex color string (with or without '#' prefix).
+    
+    Returns:
+        Color: New Color object from the hex string.
+    
+    Examples:
+        from_hex("#FF00FF")      # Magenta, full opacity
+        from_hex("#FF00FF80")    # Magenta, 50% opacity
+        from_hex("#F0F")         # Same as "#FF00FF"
+        from_hex("RGB")          # Without '#' prefix
+    """
+def from_hsv(h: typing.SupportsFloat, s: typing.SupportsFloat, v: typing.SupportsFloat, a: typing.SupportsFloat = 1.0) -> pykraken._core.Color:
+    """
+    Create a Color from HSV(A) values.
+    
+    Args:
+        h (float): Hue angle (0-360).
+        s (float): Saturation (0-1).
+        v (float): Value/brightness (0-1).
+        a (float, optional): Alpha (0-1). Defaults to 1.0.
+    """
+def grayscale(color: pykraken._core.Color) -> pykraken._core.Color:
+    """
+    Convert a color to grayscale.
+    
+    Args:
+        color (Color): The color to convert.
+    
+    Returns:
+        Color: New Color object representing the grayscale version.
+    
+    Example:
+        grayscale(Color(255, 0, 0))  # Returns Color(76, 76, 76, 255)
+    """
+def invert(color: pykraken._core.Color) -> pykraken._core.Color:
+    """
+    Return the inverse of a color by flipping RGB channels.
+    
+    The alpha channel is preserved unchanged.
+    
+    Args:
+        color (Color): The color to invert.
+    
+    Returns:
+        Color: New Color with inverted RGB values (255 - original value).
+    
+    Example:
+        invert(Color(255, 0, 128, 200))  # Returns Color(0, 255, 127, 200)
+    """
+def lerp(a: pykraken._core.Color, b: pykraken._core.Color, t: typing.SupportsFloat) -> pykraken._core.Color:
+    """
+    Linearly interpolate between two colors.
+    
+    Performs component-wise linear interpolation between start and end colors.
+    All RGBA channels are interpolated independently.
+    
+    Args:
+        a (Color): Start color (when t=0.0).
+        b (Color): End color (when t=1.0).
+        t (float): Blend factor. Values outside [0,1] will extrapolate.
+    
+    Returns:
+        Color: New interpolated color.
+    
+    Examples:
+        lerp(Color.RED, Color.BLUE, 0.5)    # Purple (halfway between red and blue)
+        lerp(Color.BLACK, Color.WHITE, 0.25) # Dark gray
+    """
+BLACK: pykraken._core.Color  # value = Color(0, 0, 0, 255)
+BLUE: pykraken._core.Color  # value = Color(0, 0, 255, 255)
+BROWN: pykraken._core.Color  # value = Color(139, 69, 19, 255)
+CYAN: pykraken._core.Color  # value = Color(0, 255, 255, 255)
+DARK_GRAY: pykraken._core.Color  # value = Color(64, 64, 64, 255)
+DARK_GREY: pykraken._core.Color  # value = Color(64, 64, 64, 255)
+GRAY: pykraken._core.Color  # value = Color(128, 128, 128, 255)
+GREEN: pykraken._core.Color  # value = Color(0, 255, 0, 255)
+GREY: pykraken._core.Color  # value = Color(128, 128, 128, 255)
+LIGHT_GRAY: pykraken._core.Color  # value = Color(192, 192, 192, 255)
+LIGHT_GREY: pykraken._core.Color  # value = Color(192, 192, 192, 255)
+MAGENTA: pykraken._core.Color  # value = Color(255, 0, 255, 255)
+MAROON: pykraken._core.Color  # value = Color(128, 0, 0, 255)
+NAVY: pykraken._core.Color  # value = Color(0, 0, 128, 255)
+OLIVE: pykraken._core.Color  # value = Color(128, 128, 0, 255)
+ORANGE: pykraken._core.Color  # value = Color(255, 165, 0, 255)
+PINK: pykraken._core.Color  # value = Color(255, 192, 203, 255)
+PURPLE: pykraken._core.Color  # value = Color(128, 0, 128, 255)
+RED: pykraken._core.Color  # value = Color(255, 0, 0, 255)
+TEAL: pykraken._core.Color  # value = Color(0, 128, 128, 255)
+WHITE: pykraken._core.Color  # value = Color(255, 255, 255, 255)
+YELLOW: pykraken._core.Color  # value = Color(255, 255, 0, 255)

pykraken/_core/draw.pyi

@@ -0,0 +1,95 @@
+"""
+Functions for drawing shape objects
+"""
+from __future__ import annotations
+import collections.abc
+import numpy
+import numpy.typing
+import pykraken._core
+import typing
+__all__: list[str] = ['circle', 'line', 'point', 'points', 'points_from_ndarray', 'polygon', 'rect', 'rects']
+def circle(circle: pykraken._core.Circle, color: pykraken._core.Color, thickness: typing.SupportsInt = 0) -> None:
+    """
+    Draw a circle to the renderer.
+    
+    Args:
+        circle (Circle): The circle to draw.
+        color (Color): The color of the circle.
+        thickness (int, optional): The line thickness. If 0 or >= radius, draws filled circle.
+                                  Defaults to 0 (filled).
+    """
+def line(line: pykraken._core.Line, color: pykraken._core.Color, thickness: typing.SupportsInt = 1) -> None:
+    """
+    Draw a line to the renderer.
+    
+    Args:
+        line (Line): The line to draw.
+        color (Color): The color of the line.
+        thickness (int, optional): The line thickness in pixels. Defaults to 1.
+    """
+def point(point: pykraken._core.Vec2, color: pykraken._core.Color) -> None:
+    """
+    Draw a single point to the renderer.
+    
+    Args:
+        point (Vec2): The position of the point.
+        color (Color): The color of the point.
+    
+    Raises:
+        RuntimeError: If point rendering fails.
+    """
+def points(points: collections.abc.Sequence[pykraken._core.Vec2], color: pykraken._core.Color) -> None:
+    """
+    Batch draw an array of points to the renderer.
+    
+    Args:
+        points (Sequence[Vec2]): The points to batch draw.
+        color (Color): The color of the points.
+    
+    Raises:
+        RuntimeError: If point rendering fails.
+    """
+def points_from_ndarray(points: typing.Annotated[numpy.typing.ArrayLike, numpy.float64], color: pykraken._core.Color) -> None:
+    """
+    Batch draw points from a NumPy array.
+    
+    This fast path accepts a contiguous NumPy array of shape (N,2) (dtype float64) and
+    reads coordinates directly with minimal overhead. Use this to measure the best-case
+    zero-copy/buffer-backed path.
+    
+    Args:
+        points (numpy.ndarray): Array with shape (N,2) containing x,y coordinates.
+        color (Color): The color of the points.
+    
+    Raises:
+        ValueError: If the array shape is not (N,2).
+        RuntimeError: If point rendering fails.
+    """
+def polygon(polygon: pykraken._core.Polygon, color: pykraken._core.Color, filled: bool = False) -> None:
+    """
+    Draw a polygon to the renderer.
+    
+    Args:
+        polygon (Polygon): The polygon to draw.
+        color (Color): The color of the polygon.
+        filled (bool, optional): Whether to draw a filled polygon or just the outline.
+                                 Defaults to False (outline). Works with both convex and concave polygons.
+    """
+def rect(rect: pykraken._core.Rect, color: pykraken._core.Color, thickness: typing.SupportsInt = 0) -> None:
+    """
+    Draw a rectangle to the renderer.
+    
+    Args:
+        rect (Rect): The rectangle to draw.
+        color (Color): The color of the rectangle.
+        thickness (int, optional): The border thickness. If 0 or >= half width/height, draws filled rectangle. Defaults to 0 (filled).
+    """
+def rects(rects: collections.abc.Sequence[pykraken._core.Rect], color: pykraken._core.Color, thickness: typing.SupportsInt = 0) -> None:
+    """
+    Batch draw an array of rectangles to the renderer.
+    
+    Args:
+        rects (Sequence[Rect]): The rectangles to batch draw.
+        color (Color): The color of the rectangles.
+        thickness (int, optional): The border thickness of the rectangles. If 0 or >= half width/height, draws filled rectangles. Defaults to 0 (filled).
+    """