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

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."""
@@ -54,6 +55,11 @@ class Record(GenericValue, metaclass=RecordMeta):
         record_4 = +MyRecord  # Create a zero-initialized record
         record_5 = +MyGenericRecord[int, int]
         ```
+
+        Copying a record:
+        ```python
+        record_copy = +record
+        ```
     """
 
     _value: dict[str, Value]
@@ -178,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
         }
@@ -229,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))
@@ -254,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:
@@ -304,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()
@@ -80,12 +81,12 @@ def streams[T](cls: type[T]) -> T:
         ```python
         @streams
         class Streams:
-            stream_1: Stream[Num]  # A stream of Num values
+            stream_1: Stream[int]  # A stream of int values
             stream_2: Stream[Vec2]  # A stream of Vec2 values
-            group_1: StreamGroup[Num, 10]  # A group of 10 Num streams
+            group_1: StreamGroup[int, 10]  # A group of 10 int streams
             group_2: StreamGroup[Vec2, 5]  # A group of 5 Vec2 streams
 
-            data_field_1: Num  # A data field of type Num
+            data_field_1: int  # A data field of type int
             data_field_2: Vec2  # A data field of type Vec2
         ```
     """
@@ -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)