kraken-engine 1.0.0__cp311-cp311-macosx_11_0_arm64.whl → 1.3.0__cp311-cp311-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:
+    """
+    Check whether one rectangle completely contains another rectangle.
+    
+    Args:
+        outer (Rect): The outer rectangle.
+        inner (Rect): The inner rectangle.
+    
+    Returns:
+        bool: True if the outer rectangle completely contains the inner rectangle.
+    """
+@typing.overload
+def contains(rect: pykraken._core.Rect, circle: pykraken._core.Circle) -> bool:
+    """
+    Check whether a rectangle completely contains a circle.
+    
+    Args:
+        rect (Rect): The rectangle.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: True if the rectangle completely contains the circle.
+    """
+@typing.overload
+def contains(rect: pykraken._core.Rect, line: pykraken._core.Line) -> bool:
+    """
+    Check whether a rectangle completely contains a line.
+    
+    Args:
+        rect (Rect): The rectangle.
+        line (Line): The line.
+    
+    Returns:
+        bool: True if the rectangle completely contains the line.
+    """
+@typing.overload
+def contains(outer: pykraken._core.Circle, inner: pykraken._core.Circle) -> bool:
+    """
+    Check whether one circle completely contains another circle.
+    
+    Args:
+        outer (Circle): The outer circle.
+        inner (Circle): The inner circle.
+    
+    Returns:
+        bool: True if the outer circle completely contains the inner circle.
+    """
+@typing.overload
+def contains(circle: pykraken._core.Circle, rect: pykraken._core.Rect) -> bool:
+    """
+    Check whether a circle completely contains a rectangle.
+    
+    Args:
+        circle (Circle): The circle.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: True if the circle completely contains the rectangle.
+    """
+@typing.overload
+def contains(circle: pykraken._core.Circle, line: pykraken._core.Line) -> bool:
+    """
+    Check whether a circle completely contains a line.
+    
+    Args:
+        circle (Circle): The circle.
+        line (Line): The line.
+    
+    Returns:
+        bool: True if the circle completely contains the line.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Rect, b: pykraken._core.Rect) -> bool:
+    """
+    Check whether two rectangles overlap.
+    
+    Args:
+        a (Rect): The first rectangle.
+        b (Rect): The second rectangle.
+    
+    Returns:
+        bool: True if the rectangles overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, circle: pykraken._core.Circle) -> bool:
+    """
+    Check whether a rectangle and a circle overlap.
+    
+    Args:
+        rect (Rect): The rectangle.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: True if the rectangle and circle overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, line: pykraken._core.Line) -> bool:
+    """
+    Check whether a rectangle and a line overlap.
+    
+    Args:
+        rect (Rect): The rectangle.
+        line (Line): The line.
+    
+    Returns:
+        bool: True if the rectangle and line overlap.
+    """
+@typing.overload
+def overlap(rect: pykraken._core.Rect, point: pykraken._core.Vec2) -> bool:
+    """
+    Check whether a rectangle contains a point.
+    
+    Args:
+        rect (Rect): The rectangle.
+        point (Vec2): The point.
+    
+    Returns:
+        bool: True if the rectangle contains the point.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Circle, b: pykraken._core.Circle) -> bool:
+    """
+    Check whether two circles overlap.
+    
+    Args:
+        a (Circle): The first circle.
+        b (Circle): The second circle.
+    
+    Returns:
+        bool: True if the circles overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, rect: pykraken._core.Rect) -> bool:
+    """
+    Check whether a circle and a rectangle overlap.
+    
+    Args:
+        circle (Circle): The circle.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: True if the circle and rectangle overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, line: pykraken._core.Line) -> bool:
+    """
+    Check whether a circle and a line overlap.
+    
+    Args:
+        circle (Circle): The circle.
+        line (Line): The line.
+    
+    Returns:
+        bool: True if the circle and line overlap.
+    """
+@typing.overload
+def overlap(circle: pykraken._core.Circle, point: pykraken._core.Vec2) -> bool:
+    """
+    Check whether a circle contains a point.
+    
+    Args:
+        circle (Circle): The circle.
+        point (Vec2): The point.
+    
+    Returns:
+        bool: True if the circle contains the point.
+    """
+@typing.overload
+def overlap(a: pykraken._core.Line, b: pykraken._core.Line) -> bool:
+    """
+    Check whether two lines overlap (intersect).
+    
+    Args:
+        a (Line): The first line.
+        b (Line): The second line.
+    
+    Returns:
+        bool: True if the lines intersect.
+    """
+@typing.overload
+def overlap(line: pykraken._core.Line, rect: pykraken._core.Rect) -> bool:
+    """
+    Check whether a line and a rectangle overlap.
+    
+    Args:
+        line (Line): The line.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: True if the line and rectangle overlap.
+    """
+@typing.overload
+def overlap(line: pykraken._core.Line, circle: pykraken._core.Circle) -> bool:
+    """
+    Check whether a line and a circle overlap.
+    
+    Args:
+        line (Line): The line.
+        circle (Circle): The circle.
+    
+    Returns:
+        bool: True if the line and circle overlap.
+    """
+@typing.overload
+def overlap(point: pykraken._core.Vec2, rect: pykraken._core.Rect) -> bool:
+    """
+    Check whether a point is inside a rectangle.
+    
+    Args:
+        point (Vec2): The point.
+        rect (Rect): The rectangle.
+    
+    Returns:
+        bool: True if the point is inside the rectangle.
+    """
+@typing.overload
+def overlap(point: pykraken._core.Vec2, circle: pykraken._core.Circle) -> bool:
+    """
+    Check whether a point is inside a circle.
+    
+    Args:
+        point (Vec2): The point.
+        circle (Circle): The circle.
+    
+    Returns:
+        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/renderer.pyi

@@ -4,7 +4,7 @@ Functions for rendering graphics
 from __future__ import annotations
 import pykraken._core
 import typing
-__all__: list[str] = ['clear', 'draw', 'get_res', 'present']
+__all__: list[str] = ['clear', 'draw', 'get_res', 'present', 'read_pixels']
 @typing.overload
 def clear(color: typing.Any = None) -> None:
     """
@@ -30,22 +30,22 @@ def clear(r: typing.SupportsInt, g: typing.SupportsInt, b: typing.SupportsInt, a
 @typing.overload
 def draw(texture: pykraken._core.Texture, dst: pykraken._core.Rect, src: typing.Any = None) -> None:
     """
-        Render a texture with specified destination and source rectangles.
+    Render a texture with specified destination and source rectangles.
     
-        Args:
-            texture (Texture): The texture to render.
-            dst (Rect): The destination rectangle on the renderer.
-            src (Rect, optional): The source rectangle from the texture. Defaults to entire texture if not specified.
+    Args:
+        texture (Texture): The texture to render.
+        dst (Rect): The destination rectangle on the renderer.
+        src (Rect, optional): The source rectangle from the texture. Defaults to entire texture if not specified.
     """
 @typing.overload
 def draw(texture: pykraken._core.Texture, pos: typing.Any = None, anchor: pykraken._core.Anchor = pykraken._core.Anchor.CENTER) -> None:
     """
-        Render a texture at the specified position with anchor alignment.
+    Render a texture at the specified position with anchor alignment.
     
-        Args:
-            texture (Texture): The texture to render.
-            pos (Vec2, optional): The position to draw at. Defaults to (0, 0).
-            anchor (Anchor, optional): The anchor point for positioning. Defaults to CENTER.
+    Args:
+        texture (Texture): The texture to render.
+        pos (Vec2, optional): The position to draw at. Defaults to (0, 0).
+        anchor (Anchor, optional): The anchor point for positioning. Defaults to CENTER.
     """
 def get_res() -> pykraken._core.Vec2:
     """
@@ -61,3 +61,14 @@ def present() -> None:
     This finalizes the current frame and displays it. Should be called after
     all drawing operations for the frame are complete.
     """
+def read_pixels(src: typing.Any = None) -> pykraken._core.PixelArray:
+    """
+    Read pixel data from the renderer within the specified rectangle.
+    
+    Args:
+        src (Rect, optional): The rectangle area to read pixels from. Defaults to entire renderer if None.
+    Returns:
+        PixelArray: An array containing the pixel data.
+    Raises:
+        RuntimeError: If reading pixels fails.
+    """

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

@@ -0,0 +1,47 @@
+from pydantic import BaseModel
+import struct
+
+
+class ShaderUniform(BaseModel):
+    """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:
+        """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: Packed binary representation of the uniform data.
+
+        Raises:
+            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 = []
+        
+        for name, value in self.model_dump().items():
+            if isinstance(value, float):
+                fmt += "f"; values.append(value)
+            elif isinstance(value, int):
+                fmt += "i"; values.append(value)
+            elif isinstance(value, bool):
+                fmt += "?"; values.append(value)
+            elif isinstance(value, (tuple, list)):
+                n = len(value)
+                if n not in (2, 3, 4):
+                    raise ValueError(f"Field '{name}' length {n} invalid, must be 2, 3, or 4.")
+                fmt += f"{n}f"
+                values.extend(map(float, value))
+            else:
+                raise TypeError(f"Unsupported uniform field '{name}' of type '{type(value)}'")
+
+        return struct.pack(fmt, *values)

pykraken/shader_uniform.pyi

@@ -0,0 +1,51 @@
+from __future__ import annotations
+import inspect
+import pydantic._internal._decorators
+import pydantic.main
+from pydantic.main import BaseModel
+import pydantic_core._pydantic_core
+import struct as struct
+import typing
+__all__: list[str] = ['BaseModel', 'ShaderUniform', 'struct']
+class ShaderUniform(pydantic.main.BaseModel):
+    """
+    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.
+    """
+    __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: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] = {}
+    __pydantic_generic_metadata__: typing.ClassVar[dict] = {'origin': None, 'args': tuple(), 'parameters': tuple()}
+    __pydantic_parent_namespace__ = None
+    __pydantic_post_init__ = None
+    __pydantic_serializer__: typing.ClassVar[pydantic_core._pydantic_core.SchemaSerializer]  # value = SchemaSerializer(serializer=Model(...
+    __pydantic_setattr_handlers__: typing.ClassVar[dict] = {}
+    __pydantic_validator__: typing.ClassVar[pydantic_core._pydantic_core.SchemaValidator]  # value = SchemaValidator(title="ShaderUniform", validator=Model(...
+    __signature__: typing.ClassVar[inspect.Signature]  # value = <Signature () -> None>
+    _abc_impl: typing.ClassVar[_abc._abc_data]  # value = <_abc._abc_data object>
+    model_config: typing.ClassVar[dict] = {}
+    def to_bytes(self) -> bytes:
+        """
+        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: Packed binary representation of the uniform data.
+        
+        Raises:
+            ValueError: If a tuple or list field does not contain 2, 3, or 4 values.
+            TypeError: If a field uses an unsupported type.
+        """

kraken_engine-1.0.0.dist-info/RECORD

@@ -1,24 +0,0 @@
-pykraken/__init__.pyi,sha256=65hwZTYHpcl2SHro0SSd-qwfrQms3yFaBM7i33z-gB0,27931
-pykraken/__init__.py,sha256=0zpBfzO64sy3FMVSKxe4TzTdDEXGpDaPHgG23YWlvts,21
-pykraken/_core.cpython-311-darwin.so,sha256=19eZwynuhjeDiV1WtlTpyXwfIf3VsVTL-gkEPCf7upM,6009096
-pykraken/__pyinstaller/hook-pykraken.py,sha256=g7IX7uKjsqfzHgXctHGbUiC2Ssy6XV3wg_HMNgxxnNg,356
-pykraken/_core/color.pyi,sha256=wKo4Z6uxTUvZQ2d8XGn7Uumk_oW4G8rbRGotMoBUzbw,4574
-pykraken/_core/window.pyi,sha256=mb09p7CBz1WGr7_dauwHiqbaQgT330dG3Jn69iuvT3M,3355
-pykraken/_core/math.pyi,sha256=WFHYUamcz1ONwpnYJsKhUAiDMzD1r1PbEgsu3V4t6Og,5038
-pykraken/_core/gamepad.pyi,sha256=q79k3FWYaHQ7okfxObm_gjPPwyyfLbGtGgIGGXGAgJA,3373
-pykraken/_core/mouse.pyi,sha256=_mag12XmC9RmiI4NZvCd3vMfuKB0bofvtpPxPraL1Kw,2367
-pykraken/_core/__init__.pyi,sha256=omfFsGgXh51bH3uRFrNEJOzHH_DzGD976e7qA9v0e9M,137998
-pykraken/_core/line.pyi,sha256=eCwWYWWib9eeT65YlhB0ssju8Rfr8x6VRA7qMhKjQn4,321
-pykraken/_core/input.pyi,sha256=1nTigN2f4PIU0IUgbtD8LztXFPZae4v4jZDvB9weyqA,2383
-pykraken/_core/key.pyi,sha256=KZb4IwOVClFU56lNlJmjVULiW24HnluChlgg8QS80L0,1867
-pykraken/_core/renderer.pyi,sha256=PIn9jf86r3vFKInxdH2hMPMRoq-czW5Q0ieRnerMgug,2252
-pykraken/_core/time.pyi,sha256=sNn2XXsXPvDaocl17_epmpLjIXwcyvAD5Gy5W1-B72k,2548
-pykraken/_core/event.pyi,sha256=3mbbHrG-02_EpQ9PUp8EqqHMp_p-LxTmJuKxjgtZeRY,386
-pykraken/_core/rect.pyi,sha256=TUbtviTvFgCbjOJ4vCO1e0OF0B9IOt5L4ykgCNOwIKI,2772
-pykraken/_core/ease.pyi,sha256=C9-I9vb1gL3OgIsmDOJc45aENNCEQBXqrobYsTj_FGE,6440
-pykraken/_core/draw.pyi,sha256=8HzUGc35gzng61mJ0Zx6Tz7ymbAv-1143fqmkulHyO8,3738
-pykraken/_core/transform.pyi,sha256=kgR_7iLo6fP1m4wMh5Ps07S-qMhH8lbWS5QKw89kA1A,5445
-kraken_engine-1.0.0.dist-info/RECORD,,
-kraken_engine-1.0.0.dist-info/WHEEL,sha256=4CYzI0otigkuiH5g2UotkgFRS-CesfbfVqGyA9q_pdY,141
-kraken_engine-1.0.0.dist-info/METADATA,sha256=TtTfVjwIaqsaWegjXkH2ia63xZwO24LwHhIZAnFoD50,2066
-kraken_engine-1.0.0.dist-info/licenses/LICENSE,sha256=4NUSEGSVvPUQ_2qD0hmmw_cOamv68n-TFiIpcIEK2eM,1094