sonolus.py 0.3.4__py3-none-any.whl → 0.4.0__py3-none-any.whl

sonolus/script/quad.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Protocol, Self
+from typing import Protocol
 
 from sonolus.script.record import Record
 from sonolus.script.values import zeros
@@ -57,7 +57,7 @@ class Quad(Record):
         """The center of the quad."""
         return (self.bl + self.tr + self.tl + self.br) / 4
 
-    def translate(self, translation: Vec2, /) -> Self:
+    def translate(self, translation: Vec2, /) -> Quad:
         """Translate the quad by the given translation and return a new quad."""
         return Quad(
             bl=self.bl + translation,
@@ -66,7 +66,7 @@ class Quad(Record):
             br=self.br + translation,
         )
 
-    def scale(self, factor: Vec2, /) -> Self:
+    def scale(self, factor: Vec2, /) -> Quad:
         """Scale the quad by the given factor about the origin and return a new quad."""
         return Quad(
             bl=self.bl * factor,
@@ -75,7 +75,7 @@ class Quad(Record):
             br=self.br * factor,
         )
 
-    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Self:
+    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Quad:
         """Scale the quad by the given factor about the given pivot and return a new quad."""
         return Quad(
             bl=(self.bl - pivot) * factor + pivot,
@@ -84,7 +84,7 @@ class Quad(Record):
             br=(self.br - pivot) * factor + pivot,
         )
 
-    def scale_centered(self, factor: Vec2, /) -> Self:
+    def scale_centered(self, factor: Vec2, /) -> Quad:
         """Scale the quad by the given factor about its center and return a new quad."""
         return Quad(
             bl=self.bl * factor,
@@ -93,7 +93,7 @@ class Quad(Record):
             br=self.br * factor,
         ).translate(self.center * (Vec2(1, 1) - factor))
 
-    def rotate(self, angle: float, /) -> Self:
+    def rotate(self, angle: float, /) -> Quad:
         """Rotate the quad by the given angle about the origin and return a new quad.
 
         Args:
@@ -114,7 +114,7 @@ class Quad(Record):
         angle: float,
         /,
         pivot: Vec2,
-    ) -> Self:
+    ) -> Quad:
         """Rotate the quad by the given angle about the given pivot and return a new quad.
 
         Args:
@@ -131,7 +131,7 @@ class Quad(Record):
             br=self.br.rotate_about(angle, pivot),
         )
 
-    def rotate_centered(self, angle: float, /) -> Self:
+    def rotate_centered(self, angle: float, /) -> Quad:
         """Rotate the quad by the given angle about its center and return a new quad.
 
         Args:
@@ -142,7 +142,7 @@ class Quad(Record):
         """
         return self.rotate_about(angle, self.center)
 
-    def permute(self, count: int = 1, /) -> Self:
+    def permute(self, count: int = 1, /) -> Quad:
         """Perform a cyclic permutation of the quad's vertices and return a new quad.
 
         On a square, this operation is equivalent to rotating the square counterclockwise 90 degrees `count` times.
@@ -269,7 +269,7 @@ class Rect(Record):
             br=self.br,
         )
 
-    def translate(self, translation: Vec2, /) -> Self:
+    def translate(self, translation: Vec2, /) -> Rect:
         """Translate the rectangle by the given translation and return a new rectangle."""
         return Rect(
             t=self.t + translation.y,
@@ -278,7 +278,7 @@ class Rect(Record):
             l=self.l + translation.x,
         )
 
-    def scale(self, factor: Vec2, /) -> Self:
+    def scale(self, factor: Vec2, /) -> Rect:
         """Scale the rectangle by the given factor about the origin and return a new rectangle."""
         return Rect(
             t=self.t * factor.y,
@@ -287,7 +287,7 @@ class Rect(Record):
             l=self.l * factor.x,
         )
 
-    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Self:
+    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Rect:
         """Scale the rectangle by the given factor about the given pivot and return a new rectangle."""
         return Rect(
             t=(self.t - pivot.y) * factor.y + pivot.y,
@@ -296,7 +296,7 @@ class Rect(Record):
             l=(self.l - pivot.x) * factor.x + pivot.x,
         )
 
-    def scale_centered(self, factor: Vec2, /) -> Self:
+    def scale_centered(self, factor: Vec2, /) -> Rect:
         """Scale the rectangle by the given factor about its center and return a new rectangle."""
         return Rect(
             t=self.t * factor.y,
@@ -305,7 +305,7 @@ class Rect(Record):
             l=self.l * factor.x,
         ).translate(self.center * (Vec2(1, 1) - factor))
 
-    def expand(self, expansion: Vec2, /) -> Self:
+    def expand(self, expansion: Vec2, /) -> Rect:
         """Expand the rectangle by the given amount and return a new rectangle."""
         return Rect(
             t=self.t + expansion.y,
@@ -314,7 +314,7 @@ class Rect(Record):
             l=self.l - expansion.x,
         )
 
-    def shrink(self, shrinkage: Vec2, /) -> Self:
+    def shrink(self, shrinkage: Vec2, /) -> Rect:
         """Shrink the rectangle by the given amount and return a new rectangle."""
         return Rect(
             t=self.t - shrinkage.y,

sonolus/script/record.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import inspect
+from abc import ABCMeta
 from collections.abc import Iterable
 from inspect import getmro
 from typing import Any, ClassVar, Self, TypeVar, dataclass_transform, get_origin
@@ -20,7 +21,7 @@ from sonolus.script.internal.value import BackingSource, DataValue, Value
 from sonolus.script.num import Num
 
 
-class RecordMeta(type):
+class RecordMeta(ABCMeta):
     @meta_fn
     def __pos__[T](cls: type[T]) -> T:
         """Create a zero-initialized record instance."""
@@ -183,7 +184,7 @@ class Record(GenericValue, metaclass=RecordMeta):
         result = object.__new__(cls)
         result._value = {
             field.name: field.type._from_backing_source_(
-                lambda offset, field_offset=field.offset: source((Num(offset) + Num(field_offset)).ir())
+                lambda offset, field_offset=field.offset: source((Num(offset) + Num(field_offset)).ir())  # type: ignore
             )
             for field in cls._fields
         }
@@ -234,10 +235,10 @@ class Record(GenericValue, metaclass=RecordMeta):
     def _get_(self) -> Self:
         return self
 
-    def _set_(self, value: Self):
+    def _set_(self, value: Any):
         raise TypeError("Record does not support _set_")
 
-    def _copy_from_(self, value: Self):
+    def _copy_from_(self, value: Any):
         value = self._accept_(value)
         for field in self._fields:
             field.__set__(self, field.__get__(value))
@@ -259,14 +260,14 @@ class Record(GenericValue, metaclass=RecordMeta):
         return result
 
     def __str__(self):
-        return (
-            f"{self.__class__.__name__}({', '.join(f'{field.name}={field.__get__(self)}' for field in self._fields)})"
-        )
+        return f"{self.__class__.__name__}({
+            ', '.join(f'{field.name}={field.get_internal(self)}' for field in self._fields)
+        })"
 
     def __repr__(self):
-        return (
-            f"{self.__class__.__name__}({', '.join(f'{field.name}={field.__get__(self)!r}' for field in self._fields)})"
-        )
+        return f"{self.__class__.__name__}({
+            ', '.join(f'{field.name}={field.get_internal(self)!r}' for field in self._fields)
+        })"
 
     @meta_fn
     def __eq__(self, other: Any) -> bool:
@@ -309,16 +310,19 @@ class Record(GenericValue, metaclass=RecordMeta):
 
 
 class _RecordField(SonolusDescriptor):
-    def __init__(self, name: str, type_: type[Value], index: int, offset: int):
+    def __init__(self, name: str, type_: type[Value] | Any, index: int, offset: int):
         self.name = name
         self.type = type_
         self.index = index
         self.offset = offset
 
+    def get_internal(self, instance: Record) -> Value:
+        return instance._value[self.name]
+
     def __get__(self, instance: Record | None, owner=None):
         if instance is None:
             return self
-        result = instance._value[self.name]._get_()
+        result = instance._value[self.name]._get_readonly_()
         if ctx():
             return result
         else:

sonolus/script/runtime.py

@@ -698,7 +698,7 @@ class _TouchArray:
 
 @_runtime_skin_transform
 class _SkinTransform:
-    value: Array[Array[float, 4], 4]
+    value: Array[Array[float, 4], 4]  # type: ignore
 
     @property
     @meta_fn
@@ -719,7 +719,7 @@ class _SkinTransform:
 
 @_runtime_particle_transform
 class _ParticleTransform:
-    value: Array[Array[float, 4], 4]
+    value: Array[Array[float, 4], 4]  # type: ignore
 
     @property
     @meta_fn
@@ -857,25 +857,25 @@ def is_debug() -> bool:
 @meta_fn
 def is_play() -> bool:
     """Check if the game is running in play mode."""
-    return ctx() and ctx().global_state.mode == Mode.PLAY
+    return bool(ctx() and ctx().global_state.mode == Mode.PLAY)
 
 
 @meta_fn
 def is_preview() -> bool:
     """Check if the game is running in preview mode."""
-    return ctx() and ctx().global_state.mode == Mode.PREVIEW
+    return bool(ctx() and ctx().global_state.mode == Mode.PREVIEW)
 
 
 @meta_fn
 def is_watch() -> bool:
     """Check if the game is running in watch mode."""
-    return ctx() and ctx().global_state.mode == Mode.WATCH
+    return bool(ctx() and ctx().global_state.mode == Mode.WATCH)
 
 
 @meta_fn
 def is_tutorial() -> bool:
     """Check if the game is running in tutorial mode."""
-    return ctx() and ctx().global_state.mode == Mode.TUTORIAL
+    return bool(ctx() and ctx().global_state.mode == Mode.TUTORIAL)
 
 
 @meta_fn
@@ -884,7 +884,7 @@ def is_preprocessing() -> bool:
 
     Returns True if the current callback is one of preprocess, spawn_order, spawn_time, or despawn_time.
     """
-    return ctx() and ctx().callback in {"preprocess", "spawnOrder", "spawnTime", "despawnTime"}
+    return bool(ctx() and ctx().callback in {"preprocess", "spawnOrder", "spawnTime", "despawnTime"})
 
 
 @meta_fn
@@ -1058,12 +1058,16 @@ def prev_time() -> float:
 def touches() -> ArrayLike[Touch]:
     """Get the current touches of the game."""
     if not ctx():
-        return Array[Touch, 0]()
+        return Array[Touch, 0]()  # type: ignore
     match ctx().global_state.mode:
         case Mode.PLAY:
-            return ArrayPointer[Touch](_PlayRuntimeUpdate.touch_count, ctx().blocks.RuntimeTouchArray, 0)
+            return ArrayPointer[Touch]._raw(
+                size=Num._accept_(_PlayRuntimeUpdate.touch_count),
+                block=Num._accept_(ctx().blocks.RuntimeTouchArray),
+                offset=Num._accept_(0),
+            )
         case _:
-            return Array[Touch, 0]()
+            return Array[Touch, 0]()  # type: ignore
 
 
 @meta_fn
@@ -1098,24 +1102,24 @@ def navigation_direction() -> int:
 
 def skin_transform() -> Transform2d:
     """Get the global skin transform."""
-    return _SkinTransform.transform
+    return _SkinTransform.transform  # type: ignore
 
 
 @meta_fn
 def set_skin_transform(value: Transform2d):
     """Set the global skin transform."""
-    _SkinTransform.transform._copy_from_(value)
+    _SkinTransform.transform._copy_from_(value)  # type: ignore
 
 
 def particle_transform() -> Transform2d:
     """Get the global particle transform."""
-    return _ParticleTransform.transform
+    return _ParticleTransform.transform  # type: ignore
 
 
 @meta_fn
 def set_particle_transform(value: Transform2d):
     """Set the global particle transform."""
-    _ParticleTransform.transform._copy_from_(value)
+    _ParticleTransform.transform._copy_from_(value)  # type: ignore
 
 
 def background() -> Quad:
@@ -1142,12 +1146,12 @@ _runtime_ui = RuntimeUi()
 
 def runtime_ui() -> RuntimeUi:
     """Get the runtime UI configuration."""
-    return _runtime_ui
+    return _runtime_ui  # type: ignore
 
 
 def canvas() -> _PreviewRuntimeCanvas:
     """Get the preview canvas."""
-    return _PreviewRuntimeCanvas
+    return _PreviewRuntimeCanvas  # type: ignore
 
 
 def screen() -> Rect:
@@ -1157,9 +1161,9 @@ def screen() -> Rect:
 
 def level_score() -> _LevelScore:
     """Get the level score configuration."""
-    return _LevelScore
+    return _LevelScore  # type: ignore
 
 
 def level_life() -> _LevelLife:
     """Get the level life configuration."""
-    return _LevelLife
+    return _LevelLife  # type: ignore

sonolus/script/sprite.py

@@ -267,7 +267,7 @@ def sprite(name: str) -> Any:
     return SkinSprite(name)
 
 
-type Skin = NewType("Skin", Any)
+type Skin = NewType("Skin", Any)  # type: ignore
 
 
 class RenderMode(StrEnum):

sonolus/script/stream.py

@@ -13,6 +13,7 @@ from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
 from sonolus.script.internal.value import BackingValue, Value
 from sonolus.script.iterator import SonolusIterator
+from sonolus.script.maybe import Maybe, Nothing, Some
 from sonolus.script.num import Num
 from sonolus.script.record import Record
 from sonolus.script.runtime import prev_time, time
@@ -48,7 +49,7 @@ class _StreamDataField(SonolusDescriptor):
 
     def __get__(self, instance, owner):
         _check_can_read_or_write_stream()
-        return self._get()._get_()
+        return self._get()._get_readonly_()
 
     def __set__(self, instance, value):
         _check_can_write_stream()
@@ -136,7 +137,7 @@ class _StreamBacking(BackingValue):
     id: Num
     index: Num
 
-    def __init__(self, stream_id: int, index: Num):
+    def __init__(self, stream_id: int, index: Num | int | float):
         super().__init__()
         self.id = Num._accept_(stream_id)
         self.index = Num._accept_(index)
@@ -240,10 +241,10 @@ class Stream[T](Record):
             # We still need to store something to preserve the key, so this is a special case.
             _stream_set(self.offset, key, 0)
         else:
-            for i, v in enumerate(value._to_list_()):
+            for i, v in enumerate(cast(Value, value)._to_list_()):
                 _stream_set(self.offset + i, key, Num(v))
 
-    def next_key(self, key: int | float) -> int:
+    def next_key(self, key: int | float) -> int | float:
         """Get the next key, or the key unchanged if it is the last key or the stream is empty.
 
         If the key is in the stream and there is a next key, returns the next key.
@@ -251,13 +252,13 @@ class Stream[T](Record):
         _check_can_read_stream()
         return _stream_get_next_key(self.offset, key)
 
-    def next_key_or_default(self, key: int | float, default: int | float) -> int:
+    def next_key_or_default(self, key: int | float, default: int | float) -> int | float:
         """Get the next key, or the default value if there is no next key."""
         _check_can_read_stream()
         next_key = self.next_key(key)
         return next_key if next_key > key else default
 
-    def previous_key(self, key: int | float) -> int:
+    def previous_key(self, key: int | float) -> int | float:
         """Get the previous key, or the key unchanged if it is the first key or the stream is empty.
 
         If the key is in the stream and there is a previous key, returns the previous key.
@@ -265,7 +266,7 @@ class Stream[T](Record):
         _check_can_read_stream()
         return _stream_get_previous_key(self.offset, key)
 
-    def previous_key_or_default(self, key: int | float, default: int | float) -> int:
+    def previous_key_or_default(self, key: int | float, default: int | float) -> int | float:
         """Get the previous key, or the default value if there is no previous key."""
         _check_can_read_stream()
         previous_key = self.previous_key(key)
@@ -283,12 +284,12 @@ class Stream[T](Record):
         previous_key = self.previous_key(key)
         return previous_key < key
 
-    def next_key_inclusive(self, key: int | float) -> int:
+    def next_key_inclusive(self, key: int | float) -> int | float:
         """Like `next_key`, but returns the key itself if it is in the stream."""
         _check_can_read_stream()
         return key if key in self else self.next_key(key)
 
-    def previous_key_inclusive(self, key: int | float) -> int:
+    def previous_key_inclusive(self, key: int | float) -> int | float:
         """Like `previous_key`, but returns the key itself if it is in the stream."""
         _check_can_read_stream()
         return key if key in self else self.previous_key(key)
@@ -508,21 +509,20 @@ class StreamGroup[T, Size](Record):
         _check_can_read_or_write_stream()
         assert index in self
         # Size 0 elements still need 1 stream to preserve the key.
-        return Stream[self.type_var_value(T)](max(1, sizeof(self.element_type())) * index + self.offset)
+        t = self.type_var_value(T)
+        return Stream[t](max(1, sizeof(self.element_type())) * index + self.offset)
 
 
 class _StreamAscIterator[T](Record, SonolusIterator[tuple[int | float, T]]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> tuple[int | float, T]:
-        return self.current_key, self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[tuple[int | float, T]]:
+        if self.current_key in self.stream:
+            result = (self.current_key, self.stream[self.current_key])
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamBoundedAscIterator[T](Record, SonolusIterator[tuple[int | float, T]]):
@@ -530,42 +530,36 @@ class _StreamBoundedAscIterator[T](Record, SonolusIterator[tuple[int | float, T]
     current_key: int | float
     end_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream and self.current_key <= self.end_key
-
-    def get(self) -> tuple[int | float, T]:
-        return self.current_key, self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[tuple[int | float, T]]:
+        if self.current_key in self.stream and self.current_key <= self.end_key:
+            result = (self.current_key, self.stream[self.current_key])
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamDescIterator[T](Record, SonolusIterator[tuple[int | float, T]]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> tuple[int | float, T]:
-        return self.current_key, self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+    def next(self) -> Maybe[tuple[int | float, T]]:
+        if self.current_key in self.stream:
+            result = (self.current_key, self.stream[self.current_key])
+            self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamAscKeyIterator[T](Record, SonolusIterator[int | float]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> int | float:
-        return self.current_key
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[int | float]:
+        if self.current_key in self.stream:
+            result = self.current_key
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamBoundedAscKeyIterator[T](Record, SonolusIterator[int | float]):
@@ -573,42 +567,36 @@ class _StreamBoundedAscKeyIterator[T](Record, SonolusIterator[int | float]):
     current_key: int | float
     end_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream and self.current_key <= self.end_key
-
-    def get(self) -> int | float:
-        return self.current_key
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[int | float]:
+        if self.current_key in self.stream and self.current_key <= self.end_key:
+            result = self.current_key
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamDescKeyIterator[T](Record, SonolusIterator[int | float]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> int | float:
-        return self.current_key
-
-    def advance(self):
-        self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+    def next(self) -> Maybe[int | float]:
+        if self.current_key in self.stream:
+            result = self.current_key
+            self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamAscValueIterator[T](Record, SonolusIterator[T]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> T:
-        return self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[T]:
+        if self.current_key in self.stream:
+            result = self.stream[self.current_key]
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamBoundedAscValueIterator[T](Record, SonolusIterator[T]):
@@ -616,28 +604,24 @@ class _StreamBoundedAscValueIterator[T](Record, SonolusIterator[T]):
     current_key: int | float
     end_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream and self.current_key <= self.end_key
-
-    def get(self) -> T:
-        return self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+    def next(self) -> Maybe[T]:
+        if self.current_key in self.stream and self.current_key <= self.end_key:
+            result = self.stream[self.current_key]
+            self.current_key = self.stream.next_key_or_default(self.current_key, inf)
+            return Some(result)
+        return Nothing
 
 
 class _StreamDescValueIterator[T](Record, SonolusIterator[T]):
     stream: Stream[T]
     current_key: int | float
 
-    def has_next(self) -> bool:
-        return self.current_key in self.stream
-
-    def get(self) -> T:
-        return self.stream[self.current_key]
-
-    def advance(self):
-        self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+    def next(self) -> Maybe[T]:
+        if self.current_key in self.stream:
+            result = self.stream[self.current_key]
+            self.current_key = self.stream.previous_key_or_default(self.current_key, -inf)
+            return Some(result)
+        return Nothing
 
 
 @native_function(Op.StreamGetNextKey)