sonolus.py 0.1.0__py3-none-any.whl

sonolus/script/array.py

@@ -0,0 +1,241 @@
+# ruff: noqa: A005
+from __future__ import annotations
+
+from collections.abc import Iterable
+from typing import Any, Self, final
+
+from sonolus.backend.place import BlockPlace
+from sonolus.script.debug import assert_unreachable
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.error import InternalError
+from sonolus.script.internal.generic import GenericValue
+from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.internal.value import Value
+from sonolus.script.iterator import ArrayLike
+from sonolus.script.num import Num
+
+
+@final
+class Array[T, Size](GenericValue, ArrayLike[T]):
+    _value: list[T] | BlockPlace
+
+    @classmethod
+    @meta_fn
+    def element_type(cls) -> type[T] | type[Value]:
+        return cls._get_type_arg_(T)
+
+    @classmethod
+    @meta_fn
+    def size(cls) -> int:
+        return cls._get_type_arg_(Size)
+
+    def __new__(cls, *args: T) -> Array[T, Any]:
+        if cls._type_args_ is None:
+            values = [validate_value(arg) for arg in args]
+            types = {type(value) for value in values}
+            if len(types) == 0:
+                raise ValueError(
+                    f"{cls.__name__} constructor should be used with at least one value if type is not specified"
+                )
+            if len(types) > 1:
+                raise TypeError(f"{cls.__name__} constructor should be used with values of the same type, got {types}")
+            parameterized_cls = cls[types.pop(), len(args)]
+        else:
+            values = [cls.element_type()._accept_(arg) for arg in args]
+            if len(args) != cls.size():
+                raise ValueError(f"{cls.__name__} constructor should be used with {cls.size()} values, got {len(args)}")
+            parameterized_cls = cls
+        if ctx():
+            place = ctx().alloc(size=parameterized_cls.size())
+            result: parameterized_cls = parameterized_cls._from_place_(place)
+            result._copy_from_(parameterized_cls._with_value(values))
+            return result
+        else:
+            return parameterized_cls._with_value([value._copy_() for value in values])
+
+    def __init__(self, *_args: T):
+        super().__init__()
+
+    @classmethod
+    def _with_value(cls, value) -> Self:
+        result = object.__new__(cls)
+        result._value = value
+        return result
+
+    @classmethod
+    def _size_(cls) -> int:
+        return cls.size() * cls.element_type()._size_()
+
+    @classmethod
+    def _is_value_type_(cls) -> bool:
+        return False
+
+    @classmethod
+    def _from_place_(cls, place: BlockPlace) -> Self:
+        return cls._with_value(place)
+
+    @classmethod
+    def _accepts_(cls, value: Any) -> bool:
+        return isinstance(value, cls)
+
+    @classmethod
+    def _accept_(cls, value: Any) -> Self:
+        if not cls._accepts_(value):
+            raise TypeError(f"Cannot accept value {value} as {cls.__name__}")
+        return value
+
+    def _is_py_(self) -> bool:
+        return isinstance(self._value, list)
+
+    def _as_py_(self) -> Any:
+        if not self._is_py_():
+            raise ValueError("Not a python value")
+        return self
+
+    @classmethod
+    def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
+        iterator = iter(values)
+        return cls(*(cls.element_type()._from_list_(iterator) for _ in range(cls.size())))
+
+    def _to_list_(self) -> list[float | BlockPlace]:
+        match self._value:
+            case list():
+                return [entry for value in self._value for entry in value._to_list_()]
+            case BlockPlace():
+                return [
+                    entry
+                    for i in range(self.size())
+                    for entry in self.element_type()
+                    ._from_place_(self._value.add_offset(i * self.element_type()._size_()))
+                    ._to_list_()
+                ]
+            case _:
+                assert_unreachable()
+
+    @classmethod
+    def _flat_keys_(cls, prefix: str) -> list[str]:
+        return [entry for i in range(cls.size()) for entry in cls.element_type()._flat_keys_(f"{prefix}[{i}]")]
+
+    def _get_(self) -> Self:
+        return self
+
+    def _set_(self, value: Self):
+        raise TypeError("Array does not support set_")
+
+    def _copy_from_(self, value: Self):
+        if not isinstance(value, type(self)):
+            raise TypeError("Cannot copy from different type")
+        for i in range(self.size()):
+            self[i] = value[i]
+
+    def _copy_(self) -> Self:
+        if ctx():
+            place = ctx().alloc(size=self.size())
+            result: Self = self._from_place_(place)
+            result._copy_from_(self)
+            return result
+        else:
+            return self._with_value([value._copy_() for value in self._value])
+
+    @classmethod
+    def _alloc_(cls) -> Self:
+        if ctx():
+            place = ctx().alloc(size=cls._size_())
+            return cls._from_place_(place)
+        else:
+            return cls._with_value([cls.element_type()._alloc_() for _ in range(cls.size())])
+
+    @meta_fn
+    def __getitem__(self, index: Num) -> T:
+        index: Num = Num._accept_(index)
+        if index._is_py_():
+            const_index = index._as_py_()
+            if isinstance(const_index, float) and not const_index.is_integer():
+                raise ValueError("Array index must be an integer")
+            const_index = int(const_index)
+            if not 0 <= const_index < self.size():
+                raise IndexError("Array index out of range")
+            if isinstance(self._value, list):
+                if ctx():
+                    return self._value[const_index]._get_()
+                else:
+                    return self._value[const_index]._get_()._as_py_()
+            else:
+                return (
+                    self.element_type()
+                    ._from_place_(self._value.add_offset(const_index * self.element_type()._size_()))
+                    ._get_()
+                )
+        else:
+            if not ctx():
+                raise InternalError("Unexpected non-constant index")
+            base = ctx().rom[tuple(self._to_list_())] if isinstance(self._value, list) else self._value
+            place = BlockPlace(
+                block=base.block,
+                index=(Num(base.index) + index * self.element_type()._size_()).index(),
+                offset=base.offset,
+            )
+            return self.element_type()._from_place_(place)._get_()
+
+    @meta_fn
+    def __setitem__(self, index: Num, value: T):
+        index: Num = Num._accept_(index)
+        value = self.element_type()._accept_(value)
+        if ctx():
+            if isinstance(self._value, list):
+                raise ValueError("Cannot mutate a compile time constant array")
+            base = self._value
+            place = (
+                base.add_offset(int(index._as_py_()) * self.element_type()._size_())
+                if index._is_py_()
+                else BlockPlace(
+                    block=base.block,
+                    index=(Num(base.index) + index * self.element_type()._size_()).index(),
+                    offset=base.offset,
+                )
+            )
+            dst = self.element_type()._from_place_(place)
+            if self.element_type()._is_value_type_():
+                dst._set_(value)
+            else:
+                dst._copy_from_(value)
+        else:
+            if not isinstance(self._value, list):
+                raise InternalError("Unexpected mutation of non compile time constant array")
+            const_index = index._as_py_()
+            if isinstance(const_index, float) and not const_index.is_integer():
+                raise ValueError("Array index must be an integer")
+            const_index = int(const_index)
+            if not 0 <= const_index < self.size():
+                raise IndexError("Array index out of range")
+            dst = self._value[const_index]
+            if self.element_type()._is_value_type_():
+                dst._set_(value)
+            else:
+                dst._copy_from_(value)
+
+    def __eq__(self, other):
+        if self.size() != other.size():
+            return False
+        i = 0
+        while i < self.size():
+            if self[i] != other[i]:
+                return False
+            i += 1
+        return True
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash(tuple(self[i] for i in range(self.size())))
+
+    def __str__(self):
+        if isinstance(self._value, BlockPlace):
+            return f"{type(self).__name__}({self._value}...)"
+        return f"{type(self).__name__}({", ".join(str(self[i]) for i in range(self.size()))})"
+
+    def __repr__(self):
+        if isinstance(self._value, BlockPlace):
+            return f"{type(self).__name__}({self._value}...)"
+        return f"{type(self).__name__}({", ".join(repr(self[i]) for i in range(self.size()))})"

sonolus/script/bucket.py

@@ -0,0 +1,192 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import Annotated, Any, Protocol, dataclass_transform, get_origin
+
+from sonolus.backend.mode import Mode
+from sonolus.backend.ops import Op
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.impl import meta_fn
+from sonolus.script.internal.introspection import get_field_specifiers
+from sonolus.script.internal.native import native_function
+from sonolus.script.interval import Interval
+from sonolus.script.pointer import deref
+from sonolus.script.record import Record
+from sonolus.script.sprite import Sprite
+
+
+class JudgmentWindow(Record):
+    perfect: Interval
+    great: Interval
+    good: Interval
+
+    def update(
+        self,
+        perfect: Interval | None = None,
+        great: Interval | None = None,
+        good: Interval | None = None,
+    ):
+        if perfect is not None:
+            self.perfect = perfect
+        if great is not None:
+            self.great = great
+        if good is not None:
+            self.good = good
+
+    def judge(self, actual: float, target: float) -> Judgment:
+        return _judge(
+            actual,
+            target,
+            *self.perfect.tuple,
+            *self.great.tuple,
+            *self.good.tuple,
+        )
+
+    def __mul__(self, other: float | int) -> JudgmentWindow:
+        return JudgmentWindow(
+            self.perfect * other,
+            self.great * other,
+            self.good * other,
+        )
+
+
+class Judgment(IntEnum):
+    MISS = 0
+    PERFECT = 1
+    GREAT = 2
+    GOOD = 3
+
+
+@native_function(Op.Judge)
+def _judge(
+    actual: float,
+    target: float,
+    perfect_min: float,
+    perfect_max: float,
+    great_min: float,
+    great_max: float,
+    good_min: float,
+    good_max: float,
+) -> Judgment:
+    diff = actual - target
+    if perfect_min <= diff <= perfect_max:
+        return Judgment.PERFECT
+    if great_min <= diff <= great_max:
+        return Judgment.GREAT
+    if good_min <= diff <= good_max:
+        return Judgment.GOOD
+    return Judgment.MISS
+
+
+class Bucket(Record):
+    id: int
+
+    @property
+    @meta_fn
+    def window(self) -> JudgmentWindow:
+        if not ctx():
+            raise RuntimeError("Bucket window access outside of compilation")
+        match ctx().global_state.mode:
+            case Mode.Play:
+                return deref(ctx().blocks.LevelBucket, self.id * JudgmentWindow._size_(), JudgmentWindow)
+            case Mode.Watch:
+                return deref(ctx().blocks.LevelBucket, self.id * JudgmentWindow._size_(), JudgmentWindow)
+            case _:
+                raise RuntimeError("Invalid mode for bucket window access")
+
+    @window.setter
+    @meta_fn
+    def window(self, value: JudgmentWindow):
+        if not ctx():
+            raise RuntimeError("Bucket window access outside of compilation")
+        self.window.update(value.perfect, value.great, value.good)
+
+
+@dataclass
+class BucketSprite:
+    id: int
+    fallback_id: int | None
+    x: int
+    y: int
+    w: int
+    h: int
+    rotation: float
+
+    def to_dict(self):
+        results = {
+            "id": self.id,
+            "x": self.x,
+            "y": self.y,
+            "w": self.w,
+            "h": self.h,
+            "rotation": self.rotation,
+        }
+        if self.fallback_id is not None:
+            results["fallbackId"] = self.fallback_id
+        return results
+
+
+@dataclass
+class BucketInfo:
+    sprites: list[BucketSprite]
+    unit: str | None = None
+
+    def to_dict(self):
+        results = {
+            "sprites": [sprite.to_dict() for sprite in self.sprites],
+        }
+        if self.unit is not None:
+            results["unit"] = self.unit
+        return results
+
+
+def bucket_sprite(
+    *,
+    sprite: Sprite,
+    fallback_sprite: Sprite | None = None,
+    x: int,
+    y: int,
+    w: int,
+    h: int,
+    rotation: float = 0,
+) -> BucketSprite:
+    return BucketSprite(sprite.id, fallback_sprite.id if fallback_sprite else None, x, y, w, h, rotation)
+
+
+def bucket(*, sprites: list[BucketSprite], unit: str | None = None) -> Any:
+    return BucketInfo(sprites, unit)
+
+
+class Buckets(Protocol):
+    _buckets_: list[BucketInfo]
+
+
+@dataclass_transform()
+def buckets[T](cls: type[T]) -> T | Buckets:
+    if len(cls.__bases__) != 1:
+        raise ValueError("Buckets class must not inherit from any class (except object)")
+    instance = cls()
+    bucket_info = []
+    for i, (name, annotation) in enumerate(get_field_specifiers(cls).items()):
+        if get_origin(annotation) is not Annotated:
+            raise TypeError(f"Invalid annotation for buckets: {annotation}")
+        annotation_type = annotation.__args__[0]
+        annotation_values = annotation.__metadata__
+        if annotation_type is not Bucket:
+            raise TypeError(f"Invalid annotation for buckets: {annotation}, expected annotation of type Bucket")
+        if len(annotation_values) != 1 or not isinstance(annotation_values[0], BucketInfo):
+            raise TypeError(
+                f"Invalid annotation for buckets: {annotation}, expected a single BucketInfo annotation value"
+            )
+        info = annotation_values[0]
+        bucket_info.append(info)
+        setattr(instance, name, Bucket(i))
+    instance._buckets_ = bucket_info
+    instance._is_comptime_value_ = True
+    return instance
+
+
+@buckets
+class EmptyBuckets:
+    pass

sonolus/script/callbacks.py

@@ -0,0 +1,105 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class CallbackInfo:
+    name: str
+    py_name: str
+    supports_order: bool
+    returns_value: bool
+
+
+preprocess_callback = CallbackInfo(
+    name="preprocess",
+    py_name="preprocess",
+    supports_order=True,
+    returns_value=False,
+)
+spawn_order_callback = CallbackInfo(
+    name="spawnOrder",
+    py_name="spawn_order",
+    supports_order=True,
+    returns_value=True,
+)
+should_spawn_callback = CallbackInfo(
+    name="shouldSpawn",
+    py_name="should_spawn",
+    supports_order=False,
+    returns_value=True,
+)
+initialize_callback = CallbackInfo(
+    name="initialize",
+    py_name="initialize",
+    supports_order=False,
+    returns_value=False,
+)
+update_sequential_callback = CallbackInfo(
+    name="updateSequential",
+    py_name="update_sequential",
+    supports_order=True,
+    returns_value=False,
+)
+touch_callback = CallbackInfo(
+    name="touch",
+    py_name="touch",
+    supports_order=True,
+    returns_value=False,
+)
+update_parallel_callback = CallbackInfo(
+    name="updateParallel",
+    py_name="update_parallel",
+    supports_order=False,
+    returns_value=False,
+)
+terminate_callback = CallbackInfo(
+    name="terminate",
+    py_name="terminate",
+    supports_order=False,
+    returns_value=False,
+)
+spawn_time_callback = CallbackInfo(
+    name="spawnTime",
+    py_name="spawn_time",
+    supports_order=False,
+    returns_value=True,
+)
+despawn_time_callback = CallbackInfo(
+    name="despawnTime",
+    py_name="despawn_time",
+    supports_order=False,
+    returns_value=True,
+)
+update_spawn_callback = CallbackInfo(
+    name="updateSpawn",
+    py_name="update_spawn",
+    supports_order=False,
+    returns_value=True,
+)
+
+
+def _by_name(*callbacks: CallbackInfo) -> dict[str, CallbackInfo]:
+    return {cb.py_name: cb for cb in callbacks}
+
+
+PLAY_CALLBACKS = _by_name(
+    preprocess_callback,
+    spawn_order_callback,
+    should_spawn_callback,
+    initialize_callback,
+    update_sequential_callback,
+    touch_callback,
+    update_parallel_callback,
+    terminate_callback,
+)
+WATCH_ARCHETYPE_CALLBACKS = _by_name(
+    preprocess_callback,
+    spawn_time_callback,
+    despawn_time_callback,
+    initialize_callback,
+    update_sequential_callback,
+    update_parallel_callback,
+    terminate_callback,
+)
+WATCH_GLOBAL_CALLBACKS = _by_name(
+    update_spawn_callback,
+)

sonolus/script/comptime.py

@@ -0,0 +1,146 @@
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any, Self, TypeVar, final
+
+from sonolus.backend.place import BlockPlace
+from sonolus.script.internal.generic import GenericValue
+
+
+@final
+class _Comptime[T, V](GenericValue):
+    _instance: Self | None = None
+
+    def __init__(self):
+        super().__init__()
+        raise TypeError("Comptime cannot be instantiated")
+
+    @classmethod
+    def value(cls):
+        _, value = cls._type_args_
+        if isinstance(value, Identity):
+            return value.value
+        return value
+
+    @classmethod
+    def _get_parameterized(cls, args: tuple[Any, ...]) -> type[Self]:
+        result = super()._get_parameterized(args)
+        result._instance = object.__new__(result)
+        return result
+
+    @classmethod
+    def _size_(cls) -> int:
+        return 0
+
+    @classmethod
+    def _is_value_type_(cls) -> bool:
+        return False
+
+    @classmethod
+    def _from_place_(cls, place: BlockPlace) -> Self:
+        return cls._instance
+
+    @classmethod
+    def _accepts_(cls, value: Any) -> bool:
+        from sonolus.script.internal.impl import validate_value
+
+        value = validate_value(value)
+        if not value._is_py_():
+            return False
+        if cls._type_args_ is None:
+            return True
+        return value._as_py_() == cls.value()
+
+    @classmethod
+    def _accept_(cls, value: Any) -> Self:
+        from sonolus.script.internal.impl import validate_value
+
+        if not cls._accepts_(value):
+            raise TypeError("Value does not match this Comptime instance")
+        # This might not actually return a Comptime instance, but it will be a compile-time constant
+        return validate_value(value)
+
+    def _is_py_(self) -> bool:
+        return True
+
+    def _as_py_(self) -> Any:
+        return self.value()
+
+    @classmethod
+    def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
+        return cls._instance
+
+    def _to_list_(self) -> list[float | BlockPlace]:
+        return []
+
+    @classmethod
+    def _flat_keys_(cls, prefix: str) -> list[str]:
+        return []
+
+    def _get_(self) -> Self:
+        from sonolus.script.internal.impl import validate_value
+
+        # Converts numbers out of comptime, although _accept_ may end up returning a non-comptime instance anyway
+        return validate_value(self.value())
+
+    def _set_(self, value: Self):
+        if value is not self:
+            raise TypeError("Comptime value cannot be changed")
+
+    def _copy_from_(self, value: Self):
+        if value is not self:
+            raise TypeError("Comptime value cannot be changed")
+
+    def _copy_(self) -> Self:
+        return self
+
+    @classmethod
+    def _alloc_(cls) -> Self:
+        return cls._instance
+
+    @classmethod
+    def _validate__type_args_(cls, args: tuple[Any, ...]) -> tuple[Any, ...]:
+        if len(args) == 2:
+            _, value = args
+            # We want the type to be there for documentation,
+            # but not enforced since they might not match up, e.g. a Callable is really FunctionType
+            if isinstance(value, TypeVar):
+                args = Any, value
+            else:
+                args = type(value), value
+        return super()._validate__type_args_(args)
+
+    @classmethod
+    def accept_unchecked(cls, value: Any) -> Self:
+        if isinstance(value, dict | tuple):
+            args = type(value), Identity(value)
+        else:
+            args = type(value), value
+        if args not in cls._parameterized_:
+            cls._parameterized_[args] = cls._get_parameterized(args)
+        return cls._parameterized_[args]._instance
+
+
+class Identity[T]:  # This is to allow accepting potentially unhashable values by using identity comparison
+    value: T
+
+    def __init__(self, value: T):
+        self.value = value
+
+    def __eq__(self, other):
+        return self is other
+
+    def __hash__(self):
+        return id(self)
+
+    def __str__(self):
+        return f"{type(self).__name__}({self.value})"
+
+    def __repr__(self):
+        return f"{type(self).__name__}({self.value!r})"
+
+
+if TYPE_CHECKING:
+    type Comptime[T, V] = T | V
+else:
+    _Comptime.__name__ = "Comptime"
+    _Comptime.__qualname__ = "Comptime"
+    globals()["Comptime"] = _Comptime