sonolus.py 0.10.6__py3-none-any.whl → 0.10.7__py3-none-any.whl

sonolus/script/containers.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
-from typing import Self
+from collections.abc import Callable
+from typing import Any, Protocol, Self
 
+from sonolus.script.archetype import AnyArchetype, EntityRef
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike, get_positive_index
 from sonolus.script.debug import error
@@ -643,3 +645,255 @@ class _ArrayMapEntryIterator[K, V, Capacity](Record, SonolusIterator):
             self._index += 1
             return Some(result)
         return Nothing
+
+
+class _LinkedListNodeRef[TKey, TValue](Protocol):
+    def get_value(self) -> TValue: ...
+
+    def get_next(self) -> Self: ...
+
+    def set_next(self, next_node: Self): ...
+
+    def set_prev(self, prev_node: Self):
+        # No-op for singly linked lists
+        return
+
+    def is_present(self) -> bool: ...
+
+    def set(self, other: Self): ...
+
+    def copy(self) -> Self: ...
+
+    def empty(self) -> Self: ...
+
+
+def _merge_linked_list_nodes[TNode: _LinkedListNodeRef](
+    a: TNode,
+    b: TNode,
+) -> TNode:
+    head = a.empty()
+    tail = a.empty()
+    left = a.copy()
+    right = b.copy()
+
+    while left.is_present() and right.is_present():
+        if left.get_value() <= right.get_value():
+            if not head.is_present():
+                head.set(left)
+                tail.set(left)
+            else:
+                tail.set_next(left)
+                tail.set(left)
+            left.set(left.get_next())
+        else:
+            if not head.is_present():
+                head.set(right)
+                tail.set(right)
+            else:
+                tail.set_next(right)
+                tail.set(right)
+            right.set(right.get_next())
+
+    while left.is_present():
+        if not head.is_present():
+            head.set(left)
+            tail.set(left)
+        else:
+            tail.set_next(left)
+            tail.set(left)
+        left.set(left.get_next())
+
+    while right.is_present():
+        if not head.is_present():
+            head.set(right)
+            tail.set(right)
+        else:
+            tail.set_next(right)
+            tail.set(right)
+        right.set(right.get_next())
+
+    if tail.is_present():
+        tail.set_next(a.empty())
+
+    return head
+
+
+def _merge_sort_linked_list_nodes[TNode: _LinkedListNodeRef](
+    head: TNode,
+) -> TNode:
+    # Calculate length
+    length = 0
+    node = head.copy()
+    while node.is_present():
+        length += 1
+        node.set(node.get_next())
+
+    # Trivial case
+    if length <= 1:
+        return head
+
+    # Bottom-up merge sort: start with sublists of size 1, then 2, 4, 8, etc.
+    size = 1
+    while size < length:
+        current = head.copy()
+        new_head = head.empty()
+        new_tail = head.empty()
+
+        # Process all pairs of sublists of the current size
+        while current.is_present():
+            # Extract the first sublist
+            left = current.copy()
+            prev = current.empty()
+            i = 0
+            while i < size and current.is_present():
+                prev.set(current)
+                current.set(current.get_next())
+                i += 1
+            if prev.is_present():
+                prev.set_next(prev.empty())
+
+            # We've made it to the end without a second sublist to merge, so just attach it to the end
+            if not current.is_present():
+                # Since size < length, we know a full iteration must have happened already, so new_tail is valid
+                new_tail.set_next(left)
+                break
+
+            # Extract the second sublist
+            right = current.copy()
+            prev = current.empty()
+            i = 0
+            while i < size and current.is_present():
+                prev.set(current)
+                current.set(current.get_next())
+                i += 1
+            if prev.is_present():
+                prev.set_next(prev.empty())
+
+            merged = _merge_linked_list_nodes(left, right)
+
+            # Append the merged result
+            if not new_head.is_present():
+                new_head.set(merged)
+                new_tail.set(merged)
+            else:
+                new_tail.set_next(merged)
+
+            # Move tail to the end of the merged section
+            while new_tail.get_next().is_present():
+                new_tail.set(new_tail.get_next())
+
+        # Update head for the next iteration
+        head.set(new_head)
+        size *= 2
+
+    return head
+
+
+class _EntityNodeRef[Archetype, GetValue, GetNextRef, GetPrevRef](Record):
+    index: int
+
+    def get_value(self) -> Any:
+        return self.get_value_fn(self.archetype.at(self.index))
+
+    def get_next(self) -> _EntityNodeRef:
+        next_ref = self.get_next_ref_fn(self.archetype.at(self.index))
+        return self.with_index(next_ref.index)
+
+    def set_next(self, next_node: _EntityNodeRef):
+        entity = self.archetype.at(self.index)
+        next_ref = self.get_next_ref_fn(entity)
+        next_ref.index = next_node.index
+
+    def set_prev(self, prev_node: _EntityNodeRef):
+        if self.get_prev_ref_fn is not None:
+            entity = self.archetype.at(self.index)
+            prev_ref = self.get_prev_ref_fn(entity)
+            prev_ref.index = prev_node.index
+
+    def is_present(self) -> bool:
+        return self.index > 0
+
+    def set(self, other: _EntityNodeRef):
+        self.index = other.index
+
+    def copy(self) -> _EntityNodeRef:
+        return self.with_index(self.index)
+
+    def empty(self) -> _EntityNodeRef:
+        return self.with_index(0)
+
+    def with_index(self, index: int) -> _EntityNodeRef:
+        return _EntityNodeRef[
+            self.archetype,
+            self.get_value_fn,
+            self.get_next_ref_fn,
+            self.get_prev_ref_fn,
+        ](index)
+
+    @property
+    def archetype(self):
+        return self.type_var_value(Archetype)
+
+    @property
+    def get_value_fn(self):
+        return self.type_var_value(GetValue)
+
+    @property
+    def get_next_ref_fn(self):
+        return self.type_var_value(GetNextRef)
+
+    @property
+    def get_prev_ref_fn(self):
+        return self.type_var_value(GetPrevRef)
+
+
+def sort_linked_entities[T: AnyArchetype](
+    head_ref: EntityRef[T],
+    /,
+    *,
+    get_value: Callable[[T], Any],
+    get_next_ref: Callable[[T], EntityRef[T]],
+    get_prev_ref: Callable[[T], EntityRef[T]] | None = None,
+) -> EntityRef[T]:
+    """Sort a linked list of entities using merge sort.
+
+    If get_prev_ref is provided, the backward links will be updated as well.
+
+    Usage:
+        ```python
+        class MyArchetype(PlayArchetype):
+            sort_key: int
+            next: EntityRef[MyArchetype]
+
+        def sort_my_archetype(head: EntityRef[MyArchetype]) -> EntityRef[MyArchetype]:
+            return sort_linked_entities(
+                head,
+                get_value=lambda e: e.sort_key,
+                get_next_ref=lambda e: e.next,
+            )
+        ```
+
+    Args:
+        head_ref: A reference to the head of the linked list.
+        get_value: A function that takes an entity and returns the value to sort by.
+        get_next_ref: A function that takes an entity and returns a reference to the next entity.
+        get_prev_ref: An optional function that takes an entity and returns a reference to the previous entity.
+
+    Returns:
+        A reference to the head of the sorted linked list.
+    """
+    archetype = head_ref.archetype()
+
+    sorted_head_index = _merge_sort_linked_list_nodes(
+        _EntityNodeRef[archetype, get_value, get_next_ref, get_prev_ref](head_ref.index)
+    ).index
+
+    if get_prev_ref is not None:
+        current_ref = _EntityNodeRef[archetype, get_value, get_next_ref, get_prev_ref](sorted_head_index)
+        prev_ref = current_ref.empty()
+        while current_ref.is_present():
+            current_ref.set_prev(prev_ref)
+            prev_ref.set(current_ref)
+            current_ref.set(current_ref.get_next())
+
+    return EntityRef[archetype](sorted_head_index)

sonolus/script/internal/builtin_impls.py

@@ -388,6 +388,11 @@ def _super(*args):
     return super(*(arg._as_py_() if arg._is_py_() else arg for arg in args))
 
 
+@meta_fn
+def _type(value):
+    return type(value)
+
+
 @meta_fn
 def _assert_never(arg: Never, /):
     error("Expected code to be unreachable")
@@ -416,6 +421,7 @@ BUILTIN_IMPLS = {
     id(range): Range,
     id(reversed): _reversed,
     id(super): _super,
+    id(type): _type,
     id(zip): _zip,
     id(assert_never): _assert_never,
     **MATH_BUILTIN_IMPLS,  # Includes round

sonolus/script/vec.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from math import pi
+
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike
 from sonolus.script.debug import assert_true
@@ -285,3 +287,22 @@ def pnpoly(vertices: ArrayLike[Vec2] | tuple[Vec2, ...], test: Vec2) -> bool:
         j = i
         i += 1
     return c
+
+
+def angle_diff(a: float, b: float, /) -> float:
+    """Return the smallest absolute difference between two angles in radians.
+
+    The result is in the range [0, π].
+    """
+    return abs((a - b + pi) % (2 * pi) - pi)
+
+
+def signed_angle_diff(a: float, b: float, /) -> float:
+    """Return the signed smallest difference between two angles in radians.
+
+    The result is in the range [-π, π). A positive result means a is counter-clockwise from b.
+    A negative result means a is clockwise from b.
+
+    If the two angles are exactly opposite, the result will be -π, but this should not be relied upon.
+    """
+    return (a - b + pi) % (2 * pi) - pi

{sonolus_py-0.10.6.dist-info → sonolus_py-0.10.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.10.6
+Version: 0.10.7
 Summary: Sonolus engine development in Python
 Project-URL: Documentation, https://sonolus.py.qwewqa.xyz/
 Project-URL: Repository, https://github.com/qwewqa/sonolus.py

{sonolus_py-0.10.6.dist-info → sonolus_py-0.10.7.dist-info}/RECORD

@@ -39,7 +39,7 @@ sonolus/script/archetype.py,sha256=ck_LR8z0ipVq3T9b735VwvQI2mxVUyjHylr4BFagXT8,4
 sonolus/script/array.py,sha256=EbrNwl_WuJ0JjjkX0s_VJNXWqvYdm_ljTbyrDEMLGUY,13348
 sonolus/script/array_like.py,sha256=E6S4TW2muXgcyVkhUASQVt7JSYUkpvdJPgHz6YiSHNo,14708
 sonolus/script/bucket.py,sha256=yIod3DgX7Hv7RLe-4Cn81FcydvbkbdMt26FzpRj7oUI,7794
-sonolus/script/containers.py,sha256=nPjyyLmGnTxndMipqdfJ9CxmIT09wNLRQM7efagtZHI,19417
+sonolus/script/containers.py,sha256=SnLXflwlX47EMQmTWnSzm9NYCi-as8lWnKzgCIK0PmM,26940
 sonolus/script/debug.py,sha256=yYg6EZt3NUOUeph1pu_5cA_2lxs8SZ91v76eOC1Sw-8,7747
 sonolus/script/easing.py,sha256=2FUJI_nfp990P_armCcRqHm2329O985glJAhSC6tnxs,11379
 sonolus/script/effect.py,sha256=SfJxSNF3RlPCRXnkt62ZlWhCXw3mmmRCsoMsvTErUP0,7960
@@ -67,9 +67,9 @@ sonolus/script/timing.py,sha256=DklMvuxcFg3MzXsecUo6Yhdk7pScOJ7STwXvAiTvLKM,3067
 sonolus/script/transform.py,sha256=4aS7-NNzX0v9KMXZ4gIGOaU1Cd-ok7DO_OvIBca0mGU,21418
 sonolus/script/ui.py,sha256=DYPGWIjHj1IFPxW1zaEuIUQx0b32FJPXtiwCvrtJ6oo,7528
 sonolus/script/values.py,sha256=6iJG6h4IDlbcK8FH4GENSHOQc7C_7fCGa34wM80qToA,1629
-sonolus/script/vec.py,sha256=s-_lplwu6UIvNpxiJHi2y1sM58-3ot1v1knAGbTJzCA,8162
+sonolus/script/vec.py,sha256=LueAHrx5pKouHvLaO1nMbl5Plh3UgPn8J7UdJPHWFCM,8840
 sonolus/script/internal/__init__.py,sha256=T6rzLoiOUaiSQtaHMZ88SNO-ijSjSSv33TKtUwu-Ms8,136
-sonolus/script/internal/builtin_impls.py,sha256=tpNbaH6fLICd8TYj9Hf_wrPSWk3RkhmSPVN9nqOuqj4,13372
+sonolus/script/internal/builtin_impls.py,sha256=b4gt54JyFoM9mhtxrhfCR8w2u38h4sJ3bzdOB0usNEs,13445
 sonolus/script/internal/callbacks.py,sha256=vWzJG8uiJoEtsNnbeZPqOHogCwoLpz2D1MnHY2wVV8s,2801
 sonolus/script/internal/constant.py,sha256=3ycbGkDJVUwcrCZ96vLjAoAARgsvaqDM8rJ_YCrLrvo,4289
 sonolus/script/internal/context.py,sha256=56pPjiPy8ZaxY3t5iEufsOMEj6BSy31G-5SoYqS6tPo,19694
@@ -87,8 +87,8 @@ sonolus/script/internal/simulation_context.py,sha256=LGxLTvxbqBIhoe1R-SfwGajNIDw
 sonolus/script/internal/transient.py,sha256=y2AWABqF1aoaP6H4_2u4MMpNioC4OsZQCtPyNI0txqo,1634
 sonolus/script/internal/tuple_impl.py,sha256=DPNdmmRmupU8Ah4_XKq6-PdT336l4nt15_uCJKQGkkk,3587
 sonolus/script/internal/value.py,sha256=OngrCdmY_h6mV2Zgwqhuo4eYFad0kTk6263UAxctZcY,6963
-sonolus_py-0.10.6.dist-info/METADATA,sha256=eg4Gb5x3XZxZZ3IV4bjs1p0ZXGUxHdiMaJlRG1_bAS8,554
-sonolus_py-0.10.6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sonolus_py-0.10.6.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
-sonolus_py-0.10.6.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
-sonolus_py-0.10.6.dist-info/RECORD,,
+sonolus_py-0.10.7.dist-info/METADATA,sha256=sXdmgTuEdNIRF2McqWR7H1c_l-uolUuow8Nt3-ZhYpY,554
+sonolus_py-0.10.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sonolus_py-0.10.7.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
+sonolus_py-0.10.7.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
+sonolus_py-0.10.7.dist-info/RECORD,,