kraken-engine 1.1.1__cp313-cp313-win_amd64.whl → 1.3.0__cp313-cp313-win_amd64.whl

pykraken/_core/collision.pyi

@@ -8,228 +8,276 @@ __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.
+    Check whether one rectangle completely contains another rectangle.
     
-    Parameters:
+    Args:
         outer (Rect): The outer rectangle.
         inner (Rect): The inner rectangle.
     
     Returns:
-        bool: Whether the outer rectangle completely contains the inner rectangle.
+        bool: True if 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.
+    Check whether a rectangle completely contains a circle.
     
-    Parameters:
+    Args:
         rect (Rect): The rectangle.
         circle (Circle): The circle.
     
     Returns:
-        bool: Whether the rectangle completely contains the circle.
+        bool: True if 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.
+    Check whether a rectangle completely contains a line.
     
-    Parameters:
+    Args:
         rect (Rect): The rectangle.
         line (Line): The line.
     
     Returns:
-        bool: Whether the rectangle completely contains the line.
+        bool: True if 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.
+    Check whether one circle completely contains another circle.
     
-    Parameters:
+    Args:
         outer (Circle): The outer circle.
         inner (Circle): The inner circle.
     
     Returns:
-        bool: Whether the outer circle completely contains the inner circle.
+        bool: True if 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.
+    Check whether a circle completely contains a rectangle.
     
-    Parameters:
+    Args:
         circle (Circle): The circle.
         rect (Rect): The rectangle.
     
     Returns:
-        bool: Whether the circle completely contains the rectangle.
+        bool: True if 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.
+    Check whether a circle completely contains a line.
     
-    Parameters:
+    Args:
         circle (Circle): The circle.
         line (Line): The line.
     
     Returns:
-        bool: Whether the circle completely contains the line.
+        bool: True if the circle completely contains the line.
     """
 @typing.overload
 def overlap(a: pykraken._core.Rect, b: pykraken._core.Rect) -> bool:
     """
-    Checks if two rectangles overlap.
+    Check whether two rectangles overlap.
     
-    Parameters:
+    Args:
         a (Rect): The first rectangle.
         b (Rect): The second rectangle.
     
     Returns:
-        bool: Whether the rectangles overlap.
+        bool: True if the rectangles overlap.
     """
 @typing.overload
 def overlap(rect: pykraken._core.Rect, circle: pykraken._core.Circle) -> bool:
     """
-    Checks if a rectangle and a circle overlap.
+    Check whether a rectangle and a circle overlap.
     
-    Parameters:
+    Args:
         rect (Rect): The rectangle.
         circle (Circle): The circle.
     
     Returns:
-        bool: Whether the rectangle and circle overlap.
+        bool: True if 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.
+    Check whether a rectangle and a line overlap.
     
-    Parameters:
+    Args:
         rect (Rect): The rectangle.
         line (Line): The line.
     
     Returns:
-        bool: Whether the rectangle and line overlap.
+        bool: True if 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.
+    Check whether a rectangle contains a point.
     
-    Parameters:
+    Args:
         rect (Rect): The rectangle.
         point (Vec2): The point.
     
     Returns:
-        bool: Whether the rectangle contains the point.
+        bool: True if the rectangle contains the point.
     """
 @typing.overload
 def overlap(a: pykraken._core.Circle, b: pykraken._core.Circle) -> bool:
     """
-    Checks if two circles overlap.
+    Check whether two circles overlap.
     
-    Parameters:
+    Args:
         a (Circle): The first circle.
         b (Circle): The second circle.
     
     Returns:
-        bool: Whether the circles overlap.
+        bool: True if the circles overlap.
     """
 @typing.overload
 def overlap(circle: pykraken._core.Circle, rect: pykraken._core.Rect) -> bool:
     """
-    Checks if a circle and a rectangle overlap.
+    Check whether a circle and a rectangle overlap.
     
-    Parameters:
+    Args:
         circle (Circle): The circle.
         rect (Rect): The rectangle.
     
     Returns:
-        bool: Whether the circle and rectangle overlap.
+        bool: True if 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.
+    Check whether a circle and a line overlap.
     
-    Parameters:
+    Args:
         circle (Circle): The circle.
         line (Line): The line.
     
     Returns:
-        bool: Whether the circle and line overlap.
+        bool: True if 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.
+    Check whether a circle contains a point.
     
-    Parameters:
+    Args:
         circle (Circle): The circle.
         point (Vec2): The point.
     
     Returns:
-        bool: Whether the circle contains the point.
+        bool: True if the circle contains the point.
     """
 @typing.overload
 def overlap(a: pykraken._core.Line, b: pykraken._core.Line) -> bool:
     """
-    Checks if two lines overlap (intersect).
+    Check whether two lines overlap (intersect).
     
-    Parameters:
+    Args:
         a (Line): The first line.
         b (Line): The second line.
     
     Returns:
-        bool: Whether the lines intersect.
+        bool: True if the lines intersect.
     """
 @typing.overload
 def overlap(line: pykraken._core.Line, rect: pykraken._core.Rect) -> bool:
     """
-    Checks if a line and a rectangle overlap.
+    Check whether a line and a rectangle overlap.
     
-    Parameters:
+    Args:
         line (Line): The line.
         rect (Rect): The rectangle.
     
     Returns:
-        bool: Whether the line and rectangle overlap.
+        bool: True if 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.
+    Check whether a line and a circle overlap.
     
-    Parameters:
+    Args:
         line (Line): The line.
         circle (Circle): The circle.
     
     Returns:
-        bool: Whether the line and circle overlap.
+        bool: True if 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.
+    Check whether a point is inside a rectangle.
     
-    Parameters:
+    Args:
         point (Vec2): The point.
         rect (Rect): The rectangle.
     
     Returns:
-        bool: Whether the point is inside the rectangle.
+        bool: True if 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.
+    Check whether a point is inside a circle.
     
-    Parameters:
+    Args:
         point (Vec2): The point.
         circle (Circle): The circle.
     
     Returns:
-        bool: Whether the point is inside the circle.
+        bool: True if the point is inside the circle.
+    """
+@typing.overload
+def overlap(polygon: pykraken._core.Polygon, point: pykraken._core.Vec2) -> bool:
+    """
+    Check whether a polygon contains a point.
+    
+    Args:
+        polygon (Polygon): The polygon.
+        point (Vec2): The point.
+    
+    Returns:
+        bool: True if the polygon contains the point.
+    """
+@typing.overload
+def overlap(point: pykraken._core.Vec2, polygon: pykraken._core.Polygon) -> bool:
+    """
+    Check whether a point is inside a polygon.
+    
+    Args:
+        point (Vec2): The point.
+        polygon (Polygon): The polygon.
+    
+    Returns:
+        bool: True if the point is inside the polygon.
+    """
+@typing.overload
+def overlap(polygon: pykraken._core.Polygon, rect: pykraken._core.Rect) -> bool:
+    """
+    Check whether a polygon and a rectangle overlap.
+    
+    Args:
+        polygon (Polygon): The polygon.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: True if the polygon and rectangle overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, polygon: pykraken._core.Polygon) -> bool:
+    """
+    Check whether a rectangle and a polygon overlap.
+    
+    Args:
+        rect (Rect): The rectangle.
+        polygon (Polygon): The polygon.
+    
+    Returns:
+        bool: True if the rectangle and polygon overlap.
     """

pykraken/_core/event.pyi

@@ -3,7 +3,28 @@ Input event handling
 """
 from __future__ import annotations
 import pykraken._core
-__all__: list[str] = ['poll']
+import typing
+__all__: list[str] = ['cancel_scheduled', 'new_custom', 'poll', 'push', 'schedule']
+def cancel_scheduled(event: pykraken._core.Event) -> None:
+    """
+    Cancel a scheduled event timer.
+    
+    Args:
+        event (Event): The custom event whose timer should be cancelled.
+    
+    Raises:
+        RuntimeError: If attempting to cancel a non-custom event type.
+    """
+def new_custom() -> pykraken._core.Event:
+    """
+    Create a new custom event type.
+    
+    Returns:
+        Event: A new Event object with a unique custom event type.
+    
+    Raises:
+        RuntimeError: If registering a custom event type fails.
+    """
 def poll() -> list[pykraken._core.Event]:
     """
     Poll for all pending user input events.
@@ -13,3 +34,27 @@ def poll() -> list[pykraken._core.Event]:
     Returns:
         list[Event]: A list of input event objects.
     """
+def push(event: pykraken._core.Event) -> None:
+    """
+    Push a custom event to the event queue.
+    
+    Args:
+        event (Event): The custom event to push to the queue.
+    
+    Raises:
+        RuntimeError: If attempting to push a non-custom event type.
+    """
+def schedule(event: pykraken._core.Event, delay_ms: typing.SupportsInt, repeat: bool = False) -> None:
+    """
+    Schedule a custom event to be pushed after a delay. Will overwrite any existing timer for the same event.
+    
+    Args:
+        event (Event): The custom event to schedule.
+        delay_ms (int): Delay in milliseconds before the event is pushed.
+        repeat (bool, optional): If True, the event will be pushed repeatedly at the
+            specified interval. If False, the event is pushed only once. Defaults to False.
+    
+    Raises:
+        RuntimeError: If attempting to schedule a non-custom event type, or if timer
+            creation fails.
+    """

pykraken/_core/math.pyi

@@ -4,7 +4,7 @@ Math related functions
 from __future__ import annotations
 import pykraken._core
 import typing
-__all__: list[str] = ['angle_between', 'clamp', 'cross', 'dot', 'from_polar', 'lerp', 'normalize', 'remap', 'scale_to_length', 'to_deg', 'to_rad']
+__all__: list[str] = ['angle_between', 'clamp', 'cross', 'dot', 'from_polar', 'lerp', 'normalize', 'remap', 'rotate', 'scale_to_length', 'to_deg', 'to_rad']
 def angle_between(a: pykraken._core.Vec2, b: pykraken._core.Vec2) -> float:
     """
     Calculate the angle between two vectors.
@@ -22,7 +22,7 @@ def clamp(vec: pykraken._core.Vec2, min_vec: pykraken._core.Vec2, max_vec: pykra
     Clamp a vector between two boundary vectors.
     
     Args:
-        vector (Vec2): The vector to clamp.
+        vec (Vec2): The vector to clamp.
         min_vec (Vec2): The minimum boundary vector.
         max_vec (Vec2): The maximum boundary vector.
     
@@ -118,7 +118,7 @@ def normalize(vec: pykraken._core.Vec2) -> pykraken._core.Vec2:
     Normalize a vector to unit length.
     
     Args:
-        vector (Vec2): The input vector.
+        vec (Vec2): The input vector.
     
     Returns:
         Vec2: A new normalized vector.
@@ -140,6 +140,17 @@ def remap(in_min: typing.SupportsFloat, in_max: typing.SupportsFloat, out_min: t
     Raises:
         ValueError: If in_min equals in_max.
     """
+def rotate(vec: pykraken._core.Vec2, radians: typing.SupportsFloat) -> pykraken._core.Vec2:
+    """
+    Rotate a vector by an angle without mutating the input.
+    
+    Args:
+        vec (Vec2): The vector to rotate.
+        radians (float): Rotation angle in radians.
+    
+    Returns:
+        Vec2: A new rotated vector.
+    """
 def scale_to_length(vector: pykraken._core.Vec2, length: typing.SupportsFloat) -> pykraken._core.Vec2:
     """
     Scale a vector to a given length.

pykraken/_core/time.pyi

@@ -52,10 +52,10 @@ def set_max_delta(max_delta: typing.SupportsFloat) -> None:
     """
     Set the maximum allowed delta time between frames.
     
-    Parameters:
-        max_delta (float): The maximum delta time in seconds, greater than 0.0.
-                           This is useful to prevent large delta values during
-                           frame drops or pauses that could destabilize physics or animations.
+    Args:
+        max_delta (float): Maximum delta time in seconds (> 0.0).
+                           Use this to avoid large deltas during frame drops or pauses
+                           that could destabilize physics or animations.
     """
 def set_scale(scale: typing.SupportsFloat) -> None:
     """

pykraken/_core/viewport.pyi

@@ -0,0 +1,30 @@
+"""
+Viewport management functions
+"""
+from __future__ import annotations
+import pykraken._core
+import typing
+__all__: list[str] = ['layout', 'set', 'unset']
+def layout(count: typing.SupportsInt, mode: pykraken._core.ViewportMode = pykraken._core.ViewportMode.VERTICAL) -> list[pykraken._core.Rect]:
+    """
+    Layout the screen into multiple viewports.
+    
+    Args:
+        count (int): The number of viewports to create (between 2 and 4).
+        mode (ViewportMode, optional): The layout mode for 2 viewports (VERTICAL or HORIZONTAL).
+                                  Defaults to VERTICAL.
+    
+    Returns:
+        list[Rect]: A list of Rects representing the viewports.
+    """
+def set(rect: pykraken._core.Rect) -> None:
+    """
+    Set the current viewport to the given rectangle.
+    
+    Args:
+        rect (Rect): The rectangle defining the viewport.
+    """
+def unset() -> None:
+    """
+    Unset the current viewport, reverting to the full rendering area.
+    """

pykraken/_core/window.pyi

@@ -13,18 +13,16 @@ def close() -> None:
     """
 def create(title: str, resolution: pykraken._core.Vec2, scaled: bool = False) -> None:
     """
-    Create a window with specified title and size.
+    Create a window with the requested title and resolution.
     
     Args:
-        title (str): The window title. Must be non-empty and <= 255 characters.
-        resolution (Vec2): The renderer resolution as (width, height).
-        scaled (bool, optional): If True, creates a scaled up window using the
-                                display's usable bounds, retaining the resolution's ratio.
-                                Defaults to False.
+        title (str): Non-empty title no longer than 255 characters.
+        resolution (Vec2): Target renderer resolution as (width, height).
+        scaled (bool): When True, stretches to usable display bounds while maintaining aspect.
     
     Raises:
-        RuntimeError: If a window already exists or window creation fails.
-        ValueError: If title is empty, exceeds 255 characters, or size values are <= 0.
+        RuntimeError: If a window already exists or SDL window creation fails.
+        ValueError: If the title is invalid or any dimension is non-positive.
     """
 def get_scale() -> int:
     """
@@ -68,7 +66,7 @@ def is_fullscreen() -> bool:
     """
 def is_open() -> bool:
     """
-    Check if the window is open.
+    Report whether the window is currently open.
     
     Returns:
         bool: True if the window is open and active.
@@ -79,6 +77,9 @@ def save_screenshot(path: str) -> None:
     
     Args:
         path (str): The path to save the screenshot to.
+    
+    Raises:
+        RuntimeError: If the window is not initialized or the screenshot cannot be saved.
     """
 def set_fullscreen(fullscreen: bool) -> None:
     """

pykraken/shader_uniform.py

@@ -3,35 +3,27 @@ import struct
 
 
 class ShaderUniform(BaseModel):
-    """
-    Base class for shader uniform data structures.
-    
-    Inherits from Pydantic's BaseModel to provide type validation and serialization
-    for shader uniform buffers. Subclass this to define your shader's uniform layout,
-    and use `to_bytes()` to convert the data to a binary format suitable for upload
-    to the GPU via `ShaderState.set_uniform()`.
-    
-    Supported field types:
-        - float: Packed as 'f' (4 bytes)
-        - int: Packed as 'i' (4 bytes, signed)
-        - bool: Packed as '?' (1 byte)
-        - tuple/list of 2-4 floats: Packed as vectors (vec2, vec3, vec4)
+    """Base model for shader uniform data structures.
+
+    Subclass this to describe your shader's uniform layout. Instances can be
+    converted to bytes for uploads through ``ShaderState.set_uniform()``. Field
+    values are packed according to their types: ``float`` values use the ``f``
+    format, ``int`` values use ``i``, ``bool`` values use ``?``, and tuples or
+    lists of two to four floats are packed as vector components.
     """
     
     def to_bytes(self) -> bytes:
-        """
-        Converts the uniform data to a packed binary format.
-        
-        Serializes all fields in the model to a bytes object using Python's struct
-        module, suitable for uploading to GPU uniform buffers. The packing format
-        is automatically determined based on field types.
-        
+        """Serialize the uniform data into a packed binary format.
+
+        The packing order follows the model's field order, and Python's ``struct``
+        module determines the byte layout based on field types.
+
         Returns:
-            bytes: The packed binary representation of the uniform data.
-        
+            bytes: Packed binary representation of the uniform data.
+
         Raises:
-            ValueError: If a tuple/list field has an invalid length (not 2, 3, or 4).
-            TypeError: If a field has an unsupported type.
+            ValueError: If a tuple or list field does not contain 2, 3, or 4 values.
+            TypeError: If a field uses an unsupported type.
         """
         fmt = ""
         values = []

pykraken/shader_uniform.pyi

@@ -9,26 +9,20 @@ import typing
 __all__: list[str] = ['BaseModel', 'ShaderUniform', 'struct']
 class ShaderUniform(pydantic.main.BaseModel):
     """
+    Base model for shader uniform data structures.
     
-    Base class for shader uniform data structures.
-    
-    Inherits from Pydantic's BaseModel to provide type validation and serialization
-    for shader uniform buffers. Subclass this to define your shader's uniform layout,
-    and use `to_bytes()` to convert the data to a binary format suitable for upload
-    to the GPU via `ShaderState.set_uniform()`.
-    
-    Supported field types:
-        - float: Packed as 'f' (4 bytes)
-        - int: Packed as 'i' (4 bytes, signed)
-        - bool: Packed as '?' (1 byte)
-        - tuple/list of 2-4 floats: Packed as vectors (vec2, vec3, vec4)
+    Subclass this to describe your shader's uniform layout. Instances can be
+    converted to bytes for uploads through ``ShaderState.set_uniform()``. Field
+    values are packed according to their types: ``float`` values use the ``f``
+    format, ``int`` values use ``i``, ``bool`` values use ``?``, and tuples or
+    lists of two to four floats are packed as vector components.
     """
     __abstractmethods__: typing.ClassVar[frozenset]  # value = frozenset()
     __class_vars__: typing.ClassVar[set] = set()
     __private_attributes__: typing.ClassVar[dict] = {}
     __pydantic_complete__: typing.ClassVar[bool] = True
     __pydantic_computed_fields__: typing.ClassVar[dict] = {}
-    __pydantic_core_schema__: typing.ClassVar[dict] = {'type': 'model', 'cls': ShaderUniform, 'schema': {'type': 'model-fields', 'fields': {}, 'model_name': 'ShaderUniform', 'computed_fields': list()}, 'custom_init': False, 'root_model': False, 'config': {'title': 'ShaderUniform'}, 'ref': 'pykraken.shader_uniform.ShaderUniform:2062985552560', 'metadata': {'pydantic_js_functions': [pydantic.main.BaseModel.__get_pydantic_json_schema__]}}
+    __pydantic_core_schema__: typing.ClassVar[dict] = {'type': 'model', 'cls': ShaderUniform, 'schema': {'type': 'model-fields', 'fields': {}, 'model_name': 'ShaderUniform', 'computed_fields': list()}, 'custom_init': False, 'root_model': False, 'config': {'title': 'ShaderUniform'}, 'ref': 'pykraken.shader_uniform.ShaderUniform:1434400820944', 'metadata': {'pydantic_js_functions': [pydantic.main.BaseModel.__get_pydantic_json_schema__]}}
     __pydantic_custom_init__: typing.ClassVar[bool] = False
     __pydantic_decorators__: typing.ClassVar[pydantic._internal._decorators.DecoratorInfos]  # value = DecoratorInfos(validators={}, field_validators={}, root_validators={}, field_serializers={}, model_serializers={}, model_validators={}, computed_fields={})
     __pydantic_fields__: typing.ClassVar[dict] = {}
@@ -43,17 +37,15 @@ class ShaderUniform(pydantic.main.BaseModel):
     model_config: typing.ClassVar[dict] = {}
     def to_bytes(self) -> bytes:
         """
+        Serialize the uniform data into a packed binary format.
         
-        Converts the uniform data to a packed binary format.
-        
-        Serializes all fields in the model to a bytes object using Python's struct
-        module, suitable for uploading to GPU uniform buffers. The packing format
-        is automatically determined based on field types.
+        The packing order follows the model's field order, and Python's ``struct``
+        module determines the byte layout based on field types.
         
         Returns:
-            bytes: The packed binary representation of the uniform data.
+            bytes: Packed binary representation of the uniform data.
         
         Raises:
-            ValueError: If a tuple/list field has an invalid length (not 2, 3, or 4).
-            TypeError: If a field has an unsupported type.
+            ValueError: If a tuple or list field does not contain 2, 3, or 4 values.
+            TypeError: If a field uses an unsupported type.
         """