sonolus.py 0.1.0__py3-none-any.whl

sonolus/script/particle.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Annotated, Any, Protocol, dataclass_transform, get_origin
+
+from sonolus.backend.ops import Op
+from sonolus.script.graphics import QuadLike, flatten_quad
+from sonolus.script.internal.introspection import get_field_specifiers
+from sonolus.script.internal.native import native_function
+from sonolus.script.record import Record
+
+
+class Particle(Record):
+    id: int
+
+    def is_available(self) -> bool:
+        return _has_particle_effect(self.id)
+
+    def spawn(self, quad: QuadLike, duration: float, loop: bool = False) -> ParticleHandle:
+        return ParticleHandle(_spawn_particle_effect(self.id, *flatten_quad(quad), duration, loop))
+
+
+class ParticleHandle(Record):
+    id: int
+
+    def move(self, quad: QuadLike) -> None:
+        _move_particle_effect(self.id, *flatten_quad(quad))
+
+    def destroy(self) -> None:
+        _destroy_particle_effect(self.id)
+
+
+@native_function(Op.HasParticleEffect)
+def _has_particle_effect(particle_id: int) -> bool:
+    raise NotImplementedError
+
+
+@native_function(Op.SpawnParticleEffect)
+def _spawn_particle_effect(
+    particle_id: int,
+    x1: float,
+    y1: float,
+    x2: float,
+    y2: float,
+    x3: float,
+    y3: float,
+    x4: float,
+    y4: float,
+    duration: float,
+    loop: bool,
+) -> int:
+    raise NotImplementedError
+
+
+@native_function(Op.MoveParticleEffect)
+def _move_particle_effect(
+    handle: int, x1: float, y1: float, x2: float, y2: float, x3: float, y3: float, x4: float, y4: float
+) -> None:
+    raise NotImplementedError
+
+
+@native_function(Op.DestroyParticleEffect)
+def _destroy_particle_effect(handle: int) -> None:
+    raise NotImplementedError
+
+
+@dataclass
+class ParticleInfo:
+    name: str
+
+
+def particle(name: str) -> Any:
+    return ParticleInfo(name)
+
+
+class Particles(Protocol):
+    _particles_: list[str]
+
+
+@dataclass_transform()
+def particles[T](cls: type[T]) -> T | Particles:
+    if len(cls.__bases__) != 1:
+        raise ValueError("Particles class must not inherit from any class (except object)")
+    instance = cls()
+    names = []
+    for i, (name, annotation) in enumerate(get_field_specifiers(cls).items()):
+        if get_origin(annotation) is not Annotated:
+            raise TypeError(f"Invalid annotation for particles: {annotation}")
+        annotation_type = annotation.__args__[0]
+        annotation_values = annotation.__metadata__
+        if annotation_type is not Particle:
+            raise TypeError(f"Invalid annotation for particles: {annotation}, expected annotation of type Particle")
+        if len(annotation_values) != 1 or not isinstance(annotation_values[0], ParticleInfo):
+            raise TypeError(
+                f"Invalid annotation for particles: {annotation}, expected a single string annotation value"
+            )
+        particle_name = annotation_values[0].name
+        names.append(particle_name)
+        setattr(instance, name, Particle(i))
+    instance._particles_ = names
+    instance._is_comptime_value_ = True
+    return instance
+
+
+class StandardParticle:
+    NoteCircularTapNeutral = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_NEUTRAL")]
+    NoteCircularTapRed = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_RED")]
+    NoteCircularTapGreen = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_GREEN")]
+    NoteCircularTapBlue = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_BLUE")]
+    NoteCircularTapYellow = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_YELLOW")]
+    NoteCircularTapPurple = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_PURPLE")]
+    NoteCircularTapCyan = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_CYAN")]
+    NoteCircularAlternativeNeutral = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_NEUTRAL")]
+    NoteCircularAlternativeRed = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_RED")]
+    NoteCircularAlternativeGreen = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_GREEN")]
+    NoteCircularAlternativeBlue = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_BLUE")]
+    NoteCircularAlternativeYellow = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_YELLOW")]
+    NoteCircularAlternativePurple = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_PURPLE")]
+    NoteCircularAlternativeCyan = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_CYAN")]
+    NoteCircularHoldNeutral = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_NEUTRAL")]
+    NoteCircularHoldRed = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_RED")]
+    NoteCircularHoldGreen = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_GREEN")]
+    NoteCircularHoldBlue = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_BLUE")]
+    NoteCircularHoldYellow = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_YELLOW")]
+    NoteCircularHoldPurple = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_PURPLE")]
+    NoteCircularHoldCyan = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_CYAN")]
+    NoteLinearTapNeutral = Annotated[Particle, particle("#NOTE_LINEAR_TAP_NEUTRAL")]
+    NoteLinearTapRed = Annotated[Particle, particle("#NOTE_LINEAR_TAP_RED")]
+    NoteLinearTapGreen = Annotated[Particle, particle("#NOTE_LINEAR_TAP_GREEN")]
+    NoteLinearTapBlue = Annotated[Particle, particle("#NOTE_LINEAR_TAP_BLUE")]
+    NoteLinearTapYellow = Annotated[Particle, particle("#NOTE_LINEAR_TAP_YELLOW")]
+    NoteLinearTapPurple = Annotated[Particle, particle("#NOTE_LINEAR_TAP_PURPLE")]
+    NoteLinearTapCyan = Annotated[Particle, particle("#NOTE_LINEAR_TAP_CYAN")]
+    NoteLinearAlternativeNeutral = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_NEUTRAL")]
+    NoteLinearAlternativeRed = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_RED")]
+    NoteLinearAlternativeGreen = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_GREEN")]
+    NoteLinearAlternativeBlue = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_BLUE")]
+    NoteLinearAlternativeYellow = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_YELLOW")]
+    NoteLinearAlternativePurple = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_PURPLE")]
+    NoteLinearAlternativeCyan = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_CYAN")]
+    NoteLinearHoldNeutral = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_NEUTRAL")]
+    NoteLinearHoldRed = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_RED")]
+    NoteLinearHoldGreen = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_GREEN")]
+    NoteLinearHoldBlue = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_BLUE")]
+    NoteLinearHoldYellow = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_YELLOW")]
+    NoteLinearHoldPurple = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_PURPLE")]
+    NoteLinearHoldCyan = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_CYAN")]
+    LaneCircular = Annotated[Particle, particle("#LANE_CIRCULAR")]
+    LaneLinear = Annotated[Particle, particle("#LANE_LINEAR")]
+    SlotCircular = Annotated[Particle, particle("#SLOT_CIRCULAR")]
+    SlotLinear = Annotated[Particle, particle("#SLOT_LINEAR")]
+    JudgeLineCircular = Annotated[Particle, particle("#JUDGE_LINE_CIRCULAR")]
+    JudgeLineLinear = Annotated[Particle, particle("#JUDGE_LINE_LINEAR")]
+
+
+@particles
+class EmptyParticles:
+    pass

sonolus/script/pointer.py

@@ -0,0 +1,30 @@
+from sonolus.backend.place import BlockPlace
+from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.internal.value import Value
+from sonolus.script.num import Num
+
+
+@meta_fn
+def deref[T: Value](block: Num, offset: Num, type_: type[T]) -> T:
+    block = Num._accept_(block)
+    offset = Num._accept_(offset)
+    type_ = validate_value(type_)._as_py_()
+    if block._is_py_():
+        block = block._as_py_()
+        if not isinstance(block, int):
+            raise TypeError("block must be an integer")
+    else:
+        if not isinstance(block, Num):
+            raise TypeError("block must be a Num")
+        block = block.index()
+    if offset._is_py_():
+        offset = offset._as_py_()
+        if not isinstance(offset, int):
+            raise TypeError("offset must be an integer")
+    else:
+        if not isinstance(offset, Num):
+            raise TypeError("offset must be a Num")
+        offset = offset.index()
+    if not (isinstance(type_, type) and issubclass(type_, Value)):
+        raise TypeError("type_ must be a Value")
+    return type_._from_place_(BlockPlace(block, offset))

sonolus/script/project.py

@@ -0,0 +1,17 @@
+from os import PathLike
+from pathlib import Path
+
+from sonolus.script.engine import Engine
+from sonolus.script.level import Level
+
+
+class Project:
+    def __init__(
+        self,
+        engine: Engine,
+        levels: list[Level] | None = None,
+        resources: PathLike | None = None,
+    ):
+        self.engine = engine
+        self.levels = levels or []
+        self.resources = Path(resources or "resources")

sonolus/script/range.py

@@ -0,0 +1,58 @@
+from sonolus.script.iterator import ArrayLike, SonolusIterator
+from sonolus.script.num import Num
+from sonolus.script.record import Record
+
+
+class Range(Record, ArrayLike[Num]):
+    start: int
+    end: int
+    step: int
+
+    def __new__(cls, start: Num, end: Num | None = None, step: Num = 1):
+        if end is None:
+            start, end = 0, start
+        return super().__new__(cls, start, end, step)
+
+    def __iter__(self) -> SonolusIterator:
+        return RangeIterator(self.start, self.end, self.step)
+
+    def __contains__(self, item):
+        if self.step > 0:
+            return self.start <= item < self.end and (item - self.start) % self.step == 0
+        else:
+            return self.end < item <= self.start and (self.start - item) % -self.step == 0
+
+    def size(self) -> int:
+        if self.step > 0:
+            diff = self.end - self.start
+            if diff <= 0:
+                return 0
+            return (diff + self.step - 1) // self.step
+        else:
+            diff = self.start - self.end
+            if diff <= 0:
+                return 0
+            return (diff - self.step - 1) // -self.step
+
+    def __getitem__(self, index: Num) -> Num:
+        return self.start + index * self.step
+
+    def __setitem__(self, index: Num, value: Num):
+        raise TypeError("Range does not support item assignment")
+
+
+class RangeIterator(Record, SonolusIterator):
+    value: int
+    end: int
+    step: int
+
+    def has_next(self) -> bool:
+        if self.step > 0:
+            return self.value < self.end
+        else:
+            return self.value > self.end
+
+    def next(self) -> Num:
+        value = self.value
+        self.value += self.step
+        return value

sonolus/script/record.py

@@ -0,0 +1,293 @@
+from __future__ import annotations
+
+import inspect
+from collections.abc import Iterable
+from inspect import getmro
+from typing import Any, ClassVar, Self, dataclass_transform, get_origin
+
+from sonolus.backend.place import BlockPlace
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.descriptor import SonolusDescriptor
+from sonolus.script.internal.generic import (
+    GenericValue,
+    accept_and_infer_types,
+    validate_and_resolve_type,
+    validate_concrete_type,
+    validate_type_spec,
+)
+from sonolus.script.internal.impl import meta_fn
+from sonolus.script.internal.value import Value
+from sonolus.script.num import Num
+
+
+@dataclass_transform(eq_default=True)
+class Record(GenericValue):
+    _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:
+            raise TypeError("Base Record class cannot have type arguments")
+        return super()._validate__type_args_(args)
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__()
+        is_parameterizing = cls._type_args_ is not None and all(
+            getattr(parent, "_type_args_", None) is None for parent in getmro(cls)[1:]
+        )
+        if is_parameterizing:
+            fields = []
+            offset = 0
+            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
+            return
+        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
+            # require object slicing. Either way, it could lead to confusion.
+            # Dealing with generic supertypes is also tricky, so it isn't really worth the effort to support this.
+            raise TypeError("Subclassing of a Record is not supported")
+
+        hints = inspect.get_annotations(cls, eval_str=True)
+        fields = []
+        params = []
+        index = 0
+        offset = 0
+        for name, hint in hints.items():
+            if name not in cls.__annotations__:
+                continue
+            if hint is ClassVar or get_origin(hint) is ClassVar:
+                continue
+            if hasattr(cls, name):
+                raise TypeError("Default values are not supported for Record fields")
+            type_ = validate_type_spec(hint)
+            fields.append(RecordField(name, type_, index, offset))
+            if isinstance(type_, type) and issubclass(type_, Value) and type_._is_concrete_():
+                offset += type_._size_()
+            setattr(cls, name, fields[-1])
+            index += 1
+            params.append(
+                inspect.Parameter(
+                    name,
+                    inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                    annotation=type_,
+                )
+            )
+
+        cls._parameterized_ = {}
+        cls._fields = fields
+        cls._constructor_signature = inspect.Signature(params)
+
+        _add_inplace_ops(cls)
+
+        cls.__match_args__ = tuple(field.name for field in fields)
+
+        if len(getattr(cls, "__type_params__", ())) == 0:
+            # Make the class behave as the parameterized version
+            cls._type_args_ = ()
+            cls._type_vars_to_args_ = {}
+            cls._parameterized_[()] = cls
+
+    def __new__(cls, *args, **kwargs):
+        # We override __new__ to allow changing to the parameterized version
+        if cls._constructor_signature is None:
+            raise TypeError(f"Cannot instantiate {cls.__name__}")
+        bound = cls._constructor_signature.bind(*args, **kwargs)
+        bound.apply_defaults()
+        values = {}
+        type_vars = {}
+        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_()
+        for type_param in cls.__type_params__:
+            if type_param not in type_vars:
+                raise TypeError(f"Type parameter {type_param} is not used")
+        type_args = tuple(type_vars[type_param] for type_param in cls.__type_params__)
+        if cls._type_args_ is not None:
+            parameterized = cls
+        else:
+            parameterized = cls[type_args]
+        result: cls = object.__new__(parameterized)  # type: ignore
+        result._value = values
+        return result
+
+    def __init__(self, *args, **kwargs):
+        # Initialization is done in __new__ and other methods
+        pass
+
+    @classmethod
+    def _raw(cls, **kwargs) -> Self:
+        result = object.__new__(cls)
+        result._value = kwargs
+        return result
+
+    @classmethod
+    def _size_(cls) -> int:
+        return sum(field.type._size_() for field in cls._fields)
+
+    @classmethod
+    def _is_value_type_(cls) -> bool:
+        return False
+
+    @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}
+        return result
+
+    @classmethod
+    def _accepts_(cls, value: Any) -> bool:
+        return issubclass(type(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 all(value._is_py_() for value in self._value.values())
+
+    def _as_py_(self) -> Self:
+        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(**{field.name: field.type._from_list_(iterator) for field in cls._fields})
+
+    def _to_list_(self) -> list[float | BlockPlace]:
+        result = []
+        for field in self._fields:
+            result.extend(self._value[field.name]._to_list_())
+        return result
+
+    @classmethod
+    def _flat_keys_(cls, prefix: str) -> list[str]:
+        result = []
+        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):
+        raise TypeError("Record does not support set_")
+
+    def _copy_from_(self, value: Self):
+        if not isinstance(value, type(self)):
+            raise TypeError("Cannot copy from different type")
+        for field in self._fields:
+            field.__set__(self, field.__get__(value))
+
+    def _copy_(self) -> Self:
+        return type(self)(**{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}
+        return result
+
+    def __str__(self):
+        return (
+            f"{self.__class__.__name__}({", ".join(f"{field.name}={field.__get__(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)})"
+        )
+
+    @meta_fn
+    def __eq__(self, other):
+        if not isinstance(other, type(self)):
+            return False
+        result: Num = Num._accept_(True)
+        for field in self._fields:
+            result = result.and_(field.__get__(self) == field.__get__(other))
+        return result
+
+    @meta_fn
+    def __ne__(self, other):
+        if not isinstance(other, type(self)):
+            return True
+        result: Num = Num._accept_(False)
+        for field in self._fields:
+            result = result.or_(field.__get__(self) != field.__get__(other))
+        return result
+
+    def __hash__(self):
+        raise TypeError("Record is not hashable")
+
+
+class RecordField(SonolusDescriptor):
+    def __init__(self, name: str, type_: type[Value], index: int, offset: int):
+        self.name = name
+        self.type = type_
+        self.index = index
+        self.offset = offset
+
+    def __get__(self, instance: Record | None, owner=None):
+        if instance is None:
+            return self
+        result = instance._value[self.name]._get_()
+        if ctx():
+            return result
+        else:
+            return result._as_py_()
+
+    def __set__(self, instance: Record, value):
+        value = self.type._accept_(value)
+        if self.type._is_value_type_():
+            instance._value[self.name]._set_(value)
+        else:
+            instance._value[self.name]._copy_from_(value)
+
+
+ops_to_inplace_ops = {
+    "__add__": "__iadd__",
+    "__sub__": "__isub__",
+    "__mul__": "__imul__",
+    "__truediv__": "__itruediv__",
+    "__floordiv__": "__ifloordiv__",
+    "__mod__": "__imod__",
+    "__pow__": "__ipow__",
+    "__lshift__": "__ilshift__",
+    "__rshift__": "__irshift__",
+    "__or__": "__ior__",
+    "__xor__": "__ixor__",
+    "__and__": "__iand__",
+    "__matmul__": "__imatmul__",
+}
+
+
+def _add_inplace_ops(cls):
+    for op, inplace_op in ops_to_inplace_ops.items():
+        if hasattr(cls, op) and not hasattr(cls, inplace_op):
+            setattr(cls, inplace_op, _make_inplace_op(op))
+    return cls
+
+
+def _make_inplace_op(op: str):
+    @meta_fn
+    def inplace_op(self, other):
+        _compiler_internal_ = True  # noqa: F841
+        self._copy_from_(getattr(self, op)(other))
+        return self
+
+    return inplace_op