kraken-engine 1.2.1__cp313-cp313-macosx_11_0_arm64.whl

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

pykraken/_core/key.pyi

@@ -0,0 +1,73 @@
+"""
+Keyboard key state checks
+"""
+from __future__ import annotations
+import pykraken._core
+import typing
+__all__: list[str] = ['is_just_pressed', 'is_just_released', 'is_pressed']
+@typing.overload
+def is_just_pressed(scancode: pykraken._core.Scancode) -> bool:
+    """
+    Check if a key was pressed this frame (by scancode).
+    
+    Args:
+        scancode (Scancode): The physical key.
+    
+    Returns:
+        bool: True if the key was newly pressed.
+    """
+@typing.overload
+def is_just_pressed(keycode: pykraken._core.Keycode) -> bool:
+    """
+    Check if a key was pressed this frame (by keycode).
+    
+    Args:
+        keycode (Keycode): The symbolic key.
+    
+    Returns:
+        bool: True if the key was newly pressed.
+    """
+@typing.overload
+def is_just_released(scancode: pykraken._core.Scancode) -> bool:
+    """
+    Check if a key was released this frame (by scancode).
+    
+    Args:
+        scancode (Scancode): The physical key.
+    
+    Returns:
+        bool: True if the key was newly released.
+    """
+@typing.overload
+def is_just_released(keycode: pykraken._core.Keycode) -> bool:
+    """
+    Check if a key was released this frame (by keycode).
+    
+    Args:
+        keycode (Keycode): The symbolic key.
+    
+    Returns:
+        bool: True if the key was newly released.
+    """
+@typing.overload
+def is_pressed(scancode: pykraken._core.Scancode) -> bool:
+    """
+    Check if a key is currently held down (by scancode).
+    
+    Args:
+        scancode (Scancode): The physical key (e.g., S_w).
+    
+    Returns:
+        bool: True if the key is held.
+    """
+@typing.overload
+def is_pressed(keycode: pykraken._core.Keycode) -> bool:
+    """
+    Check if a key is currently held down (by keycode).
+    
+    Args:
+        keycode (Keycode): The symbolic key (e.g., K_SPACE).
+    
+    Returns:
+        bool: True if the key is held.
+    """

pykraken/_core/line.pyi

@@ -0,0 +1,10 @@
+from __future__ import annotations
+import pykraken._core
+__all__: list[str] = ['move']
+def move(line: pykraken._core.Line, offset: pykraken._core.Vec2) -> pykraken._core.Line:
+    """
+    Move the given line by a Vec2 or 2-element sequence.
+    
+    Args:
+        offset (Vec2 | list[float]): The amount to move.
+    """