kraken-engine 1.0.0__cp314-cp314-macosx_11_0_arm64.whl

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).
+    """

pykraken/_core/ease.pyi

@@ -0,0 +1,285 @@
+"""
+Easing functions and animation utilities
+"""
+from __future__ import annotations
+import typing
+__all__: list[str] = ['in_back', 'in_bounce', 'in_circ', 'in_cubic', 'in_elastic', 'in_expo', 'in_out_back', 'in_out_bounce', 'in_out_circ', 'in_out_cubic', 'in_out_elastic', 'in_out_expo', 'in_out_quad', 'in_out_quart', 'in_out_quint', 'in_out_sin', 'in_quad', 'in_quart', 'in_quint', 'in_sin', 'linear', 'out_back', 'out_bounce', 'out_circ', 'out_cubic', 'out_elastic', 'out_expo', 'out_quad', 'out_quart', 'out_quint', 'out_sin']
+def in_back(t: typing.SupportsFloat) -> float:
+    """
+    Back easing in (overshoot at start).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_bounce(t: typing.SupportsFloat) -> float:
+    """
+    Bounce easing in (bounces toward target).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_circ(t: typing.SupportsFloat) -> float:
+    """
+    Circular easing in.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_cubic(t: typing.SupportsFloat) -> float:
+    """
+    Cubic easing in (very slow start).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_elastic(t: typing.SupportsFloat) -> float:
+    """
+    Elastic easing in (springy start).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_expo(t: typing.SupportsFloat) -> float:
+    """
+    Exponential easing in.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_back(t: typing.SupportsFloat) -> float:
+    """
+    Back easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_bounce(t: typing.SupportsFloat) -> float:
+    """
+    Bounce easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_circ(t: typing.SupportsFloat) -> float:
+    """
+    Circular easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_cubic(t: typing.SupportsFloat) -> float:
+    """
+    Cubic easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_elastic(t: typing.SupportsFloat) -> float:
+    """
+    Elastic easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_expo(t: typing.SupportsFloat) -> float:
+    """
+    Exponential easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_quad(t: typing.SupportsFloat) -> float:
+    """
+    Quadratic easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_quart(t: typing.SupportsFloat) -> float:
+    """
+    Quartic easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_quint(t: typing.SupportsFloat) -> float:
+    """
+    Quintic easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_out_sin(t: typing.SupportsFloat) -> float:
+    """
+    Sinusoidal easing in and out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_quad(t: typing.SupportsFloat) -> float:
+    """
+    Quadratic easing in (slow start).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_quart(t: typing.SupportsFloat) -> float:
+    """
+    Quartic easing in.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_quint(t: typing.SupportsFloat) -> float:
+    """
+    Quintic easing in.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def in_sin(t: typing.SupportsFloat) -> float:
+    """
+    Sinusoidal easing in.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def linear(t: typing.SupportsFloat) -> float:
+    """
+    Linear easing.
+    
+    Args:
+        t (float): Normalized time (0.0 to 1.0).
+    Returns:
+        float: Eased result.
+    """
+def out_back(t: typing.SupportsFloat) -> float:
+    """
+    Back easing out (overshoot at end).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_bounce(t: typing.SupportsFloat) -> float:
+    """
+    Bounce easing out (bounces after start).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_circ(t: typing.SupportsFloat) -> float:
+    """
+    Circular easing out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_cubic(t: typing.SupportsFloat) -> float:
+    """
+    Cubic easing out (fast then smooth).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_elastic(t: typing.SupportsFloat) -> float:
+    """
+    Elastic easing out (springy end).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_expo(t: typing.SupportsFloat) -> float:
+    """
+    Exponential easing out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_quad(t: typing.SupportsFloat) -> float:
+    """
+    Quadratic easing out (fast start).
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_quart(t: typing.SupportsFloat) -> float:
+    """
+    Quartic easing out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_quint(t: typing.SupportsFloat) -> float:
+    """
+    Quintic easing out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """
+def out_sin(t: typing.SupportsFloat) -> float:
+    """
+    Sinusoidal easing out.
+    
+    Args:
+        t (float): Normalized time.
+    Returns:
+        float: Eased result.
+    """

pykraken/_core/event.pyi

@@ -0,0 +1,15 @@
+"""
+Input event handling
+"""
+from __future__ import annotations
+import pykraken._core
+__all__: list[str] = ['poll']
+def poll() -> list[pykraken._core.Event]:
+    """
+    Poll for all pending user input events.
+    
+    This clears input states and returns a list of events that occurred since the last call.
+    
+    Returns:
+        list[Event]: A list of input event objects.
+    """

pykraken/_core/gamepad.pyi

@@ -0,0 +1,105 @@
+"""
+Gamepad input handling functions
+"""
+from __future__ import annotations
+import pykraken._core
+import typing
+__all__: list[str] = ['get_connected_slots', 'get_deadzone', 'get_left_stick', 'get_left_trigger', 'get_right_stick', 'get_right_trigger', 'is_just_pressed', 'is_just_released', 'is_pressed', 'set_deadzone']
+def get_connected_slots() -> list[int]:
+    """
+    Get a list of connected gamepad slot indices.
+    
+    Returns:
+        list[int]: A list of slot IDs with active gamepads.
+    """
+def get_deadzone(slot: typing.SupportsInt = 0) -> float:
+    """
+    Get the current dead zone value for a gamepad's analog sticks.
+    
+    Args:
+        slot (int, optional): Gamepad slot ID (default is 0).
+    
+    Returns:
+        float: Deadzone threshold.
+    """
+def get_left_stick(slot: typing.SupportsInt = 0) -> pykraken._core.Vec2:
+    """
+    Get the left analog stick position.
+    
+    Args:
+        slot (int, optional): Gamepad slot ID (default is 0).
+    
+    Returns:
+        Vec2: A vector of stick input normalized to [-1, 1], or (0, 0) if inside dead zone.
+    """
+def get_left_trigger(slot: typing.SupportsInt = 0) -> float:
+    """
+    Get the left trigger's current pressure value.
+    
+    Args:
+        slot (int, optional): Gamepad slot ID (default is 0).
+    
+    Returns:
+        float: Trigger value in range [0.0, 1.0].
+    """
+def get_right_stick(slot: typing.SupportsInt = 0) -> pykraken._core.Vec2:
+    """
+    Get the right analog stick position.
+    
+    Args:
+        slot (int, optional): Gamepad slot ID (default is 0).
+    
+    Returns:
+        Vec2: A vector of stick input normalized to [-1, 1], or (0, 0) if inside dead zone.
+    """
+def get_right_trigger(slot: typing.SupportsInt = 0) -> float:
+    """
+    Get the right trigger's current pressure value.
+    
+    Args:
+        slot (int, optional): Gamepad slot ID (default is 0).
+    
+    Returns:
+        float: Trigger value in range [0.0, 1.0].
+    """
+def is_just_pressed(button: pykraken._core.GamepadButton, slot: typing.SupportsInt = 0) -> bool:
+    """
+    Check if a gamepad button was pressed during this frame.
+    
+    Args:
+        button (GamepadButton): The button code.
+        slot (int, optional): Gamepad slot ID (default is 0).
+    
+    Returns:
+        bool: True if the button was just pressed.
+    """
+def is_just_released(button: pykraken._core.GamepadButton, slot: typing.SupportsInt = 0) -> bool:
+    """
+    Check if a gamepad button was released during this frame.
+    
+    Args:
+        button (GamepadButton): The button code.
+        slot (int, optional): Gamepad slot ID (default is 0).
+    
+    Returns:
+        bool: True if the button was just released.
+    """
+def is_pressed(button: pykraken._core.GamepadButton, slot: typing.SupportsInt = 0) -> bool:
+    """
+    Check if a gamepad button is currently being held down.
+    
+    Args:
+        button (GamepadButton): The button code.
+        slot (int, optional): Gamepad slot ID (default is 0).
+    
+    Returns:
+        bool: True if the button is pressed.
+    """
+def set_deadzone(deadzone: typing.SupportsFloat, slot: typing.SupportsInt = 0) -> None:
+    """
+    Set the dead zone threshold for a gamepad's analog sticks.
+    
+    Args:
+        deadzone (float): Value from 0.0 to 1.0 where movement is ignored.
+        slot (int, optional): Gamepad slot ID (default is 0).
+    """

pykraken/_core/input.pyi

@@ -0,0 +1,78 @@
+"""
+Input handling and action binding
+"""
+from __future__ import annotations
+import collections.abc
+import pykraken._core
+__all__: list[str] = ['bind', 'get_axis', 'get_direction', 'is_just_pressed', 'is_just_released', 'is_pressed', 'unbind']
+def bind(name: str, actions: collections.abc.Sequence[pykraken._core.InputAction]) -> None:
+    """
+    Bind a name to a list of InputActions.
+    
+    Args:
+        name (str): The identifier for this binding (e.g. "jump").
+        actions (list[InputAction]): One or more InputActions to bind.
+    """
+def get_axis(negative: str, positive: str) -> float:
+    """
+    Get a 1D axis value based on two opposing input actions.
+    
+    Args:
+        negative (str): Name of the negative direction action (e.g. "left").
+        positive (str): Name of the positive direction action (e.g. "right").
+    
+    Returns:
+        float: Value in range [-1.0, 1.0] based on input.
+    """
+def get_direction(up: str, right: str, down: str, left: str) -> pykraken._core.Vec2:
+    """
+    Get a directional vector based on named input actions.
+    
+    This is typically used for WASD-style or D-pad movement.
+    
+    Args:
+        up (str): Name of action for upward movement.
+        right (str): Name of action for rightward movement.
+        down (str): Name of action for downward movement.
+        left (str): Name of action for leftward movement.
+    
+    Returns:
+        Vec2: A normalized vector representing the intended direction.
+    """
+def is_just_pressed(name: str) -> bool:
+    """
+    Check if the given action was just pressed this frame.
+    
+    Args:
+        name (str): The name of the bound input.
+    
+    Returns:
+        bool: True if pressed this frame only.
+    """
+def is_just_released(name: str) -> bool:
+    """
+    Check if the given action was just released this frame.
+    
+    Args:
+        name (str): The name of the bound input.
+    
+    Returns:
+        bool: True if released this frame only.
+    """
+def is_pressed(name: str) -> bool:
+    """
+    Check if the given action is currently being held.
+    
+    Args:
+        name (str): The name of the bound input.
+    
+    Returns:
+        bool: True if any action bound to the name is pressed.
+    """
+def unbind(name: str) -> None:
+    """
+    Unbind a previously registered input name.
+    
+    Args:
+        name (str): The binding name to remove.
+    """