sonolus.py 0.3.4__py3-none-any.whl → 0.4.1__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."""
@@ -61,13 +62,13 @@ class Record(GenericValue, metaclass=RecordMeta):
         ```
     """
 
-    _value: dict[str, Value]
-    _fields: ClassVar[list[_RecordField] | None] = None
-    _constructor_signature: ClassVar[inspect.Signature]
+    _value_: dict[str, Value]
+    _fields_: ClassVar[list[_RecordField] | None] = None
+    _constructor_signature_: ClassVar[inspect.Signature]
 
     @classmethod
     def _validate_type_args_(cls, args: tuple[Any, ...]) -> tuple[Any, ...]:
-        if cls._fields is None:
+        if cls._fields_ is None:
             raise TypeError("Base Record class cannot have type arguments")
         return super()._validate_type_args_(args)
 
@@ -79,16 +80,16 @@ class Record(GenericValue, metaclass=RecordMeta):
         if is_parameterizing:
             fields = []
             offset = 0
-            for generic_field in cls._fields:
+            for generic_field in cls._fields_:
                 resolved_type = validate_and_resolve_type(generic_field.type, cls._type_vars_to_args_)
                 resolved_type = validate_concrete_type(resolved_type)
                 field = _RecordField(generic_field.name, resolved_type, generic_field.index, offset)
                 fields.append(field)
                 setattr(cls, field.name, field)
                 offset += resolved_type._size_()
-            cls._fields = fields
+            cls._fields_ = fields
             return
-        is_inheriting_from_existing_record_class = cls._fields is not None
+        is_inheriting_from_existing_record_class = cls._fields_ is not None
         if is_inheriting_from_existing_record_class and not is_parameterizing:
             # The main reason this is disallowed is that subclasses wouldn't be substitutable for their parent classes
             # Assignment of a subclass instance to a variable of the parent class would either be disallowed or would
@@ -123,8 +124,8 @@ class Record(GenericValue, metaclass=RecordMeta):
             )
 
         cls._parameterized_ = {}
-        cls._fields = fields
-        cls._constructor_signature = inspect.Signature(params)
+        cls._fields_ = fields
+        cls._constructor_signature_ = inspect.Signature(params)
 
         _add_inplace_ops(cls)
 
@@ -138,13 +139,13 @@ class Record(GenericValue, metaclass=RecordMeta):
 
     def __new__(cls, *args, **kwargs):
         # We override __new__ to allow changing to the parameterized version
-        if cls._constructor_signature is None:
+        if cls._constructor_signature_ is None:
             raise TypeError(f"Cannot instantiate {cls.__name__}")
-        bound = cls._constructor_signature.bind(*args, **kwargs)
+        bound = cls._constructor_signature_.bind(*args, **kwargs)
         bound.apply_defaults()
         values = {}
         type_vars = {}
-        for field in cls._fields:
+        for field in cls._fields_:
             value = bound.arguments[field.name]
             value = accept_and_infer_types(field.type, value, type_vars)
             values[field.name] = value._get_()
@@ -157,7 +158,7 @@ class Record(GenericValue, metaclass=RecordMeta):
         else:
             parameterized = cls[type_args]
         result: cls = object.__new__(parameterized)  # type: ignore
-        result._value = values
+        result._value_ = values
         return result
 
     def __init__(self, *args, **kwargs):
@@ -167,12 +168,12 @@ class Record(GenericValue, metaclass=RecordMeta):
     @classmethod
     def _raw(cls, **kwargs) -> Self:
         result = object.__new__(cls)
-        result._value = kwargs
+        result._value_ = kwargs
         return result
 
     @classmethod
     def _size_(cls) -> int:
-        return sum(field.type._size_() for field in cls._fields)
+        return sum(field.type._size_() for field in cls._fields_)
 
     @classmethod
     def _is_value_type_(cls) -> bool:
@@ -181,18 +182,18 @@ class Record(GenericValue, metaclass=RecordMeta):
     @classmethod
     def _from_backing_source_(cls, source: BackingSource) -> Self:
         result = object.__new__(cls)
-        result._value = {
+        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
+            for field in cls._fields_
         }
         return result
 
     @classmethod
     def _from_place_(cls, place: BlockPlace) -> Self:
         result = object.__new__(cls)
-        result._value = {field.name: field.type._from_place_(place.add_offset(field.offset)) for field in cls._fields}
+        result._value_ = {field.name: field.type._from_place_(place.add_offset(field.offset)) for field in cls._fields_}
         return result
 
     @classmethod
@@ -206,7 +207,7 @@ class Record(GenericValue, metaclass=RecordMeta):
         return value
 
     def _is_py_(self) -> bool:
-        return all(value._is_py_() for value in self._value.values())
+        return all(value._is_py_() for value in self._value_.values())
 
     def _as_py_(self) -> Self:
         if not self._is_py_():
@@ -216,64 +217,64 @@ class Record(GenericValue, metaclass=RecordMeta):
     @classmethod
     def _from_list_(cls, values: Iterable[DataValue]) -> Self:
         iterator = iter(values)
-        return cls(**{field.name: field.type._from_list_(iterator) for field in cls._fields})
+        return cls(**{field.name: field.type._from_list_(iterator) for field in cls._fields_})
 
     def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[DataValue | str]:
         result = []
-        for field in self._fields:
-            result.extend(self._value[field.name]._to_list_(level_refs))
+        for field in self._fields_:
+            result.extend(self._value_[field.name]._to_list_(level_refs))
         return result
 
     @classmethod
     def _flat_keys_(cls, prefix: str) -> list[str]:
         result = []
-        for field in cls._fields:
+        for field in cls._fields_:
             result.extend(field.type._flat_keys_(f"{prefix}.{field.name}"))
         return result
 
     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:
+        for field in self._fields_:
             field.__set__(self, field.__get__(value))
 
     def _copy_(self) -> Self:
-        return type(self)._raw(**{field.name: self._value[field.name]._copy_() for field in self._fields})
+        return type(self)._raw(**{field.name: self._value_[field.name]._copy_() for field in self._fields_})
 
     @classmethod
     def _alloc_(cls) -> Self:
         # Compared to using the constructor, this avoids unnecessary _get_ calls
         result = object.__new__(cls)
-        result._value = {field.name: field.type._alloc_() for field in cls._fields}
+        result._value_ = {field.name: field.type._alloc_() for field in cls._fields_}
         return result
 
     @classmethod
     def _zero_(cls) -> Self:
         result = object.__new__(cls)
-        result._value = {field.name: field.type._zero_() for field in cls._fields}
+        result._value_ = {field.name: field.type._zero_() for field in cls._fields_}
         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:
         if not isinstance(other, type(self)):
             return False
         result: Num = Num._accept_(True)
-        for field in self._fields:
+        for field in self._fields_:
             result = result.and_(field.__get__(self) == field.__get__(other))
         return result
 
@@ -282,12 +283,12 @@ class Record(GenericValue, metaclass=RecordMeta):
         if not isinstance(other, type(self)):
             return True
         result: Num = Num._accept_(False)
-        for field in self._fields:
+        for field in self._fields_:
             result = result.or_(field.__get__(self) != field.__get__(other))
         return result
 
     def __hash__(self):
-        return hash(tuple(field.__get__(self) for field in self._fields))
+        return hash(tuple(field.__get__(self) for field in self._fields_))
 
     @meta_fn
     def __pos__(self) -> Self:
@@ -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:
@@ -327,9 +331,9 @@ class _RecordField(SonolusDescriptor):
     def __set__(self, instance: Record, value):
         value = self.type._accept_(value)
         if self.type._is_value_type_():
-            instance._value[self.name]._set_(value)
+            instance._value_[self.name]._set_(value)
         else:
-            instance._value[self.name]._copy_from_(value)
+            instance._value_[self.name]._copy_from_(value)
 
 
 _ops_to_inplace_ops = {

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):