sonolus.py 0.1.0__py3-none-any.whl

sonolus/script/containers.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+from sonolus.script.array import Array
+from sonolus.script.debug import error
+from sonolus.script.iterator import ArrayLike, SonolusIterator
+from sonolus.script.range import Range
+from sonolus.script.record import Record
+from sonolus.script.values import alloc, copy
+
+
+class Pair[T, U](Record):
+    first: T
+    second: U
+
+
+class VarArray[T, Capacity](Record, ArrayLike[T]):
+    _size: int
+    _array: Array[T, Capacity]
+
+    @classmethod
+    def new(cls):
+        element_type = cls._get_type_arg_(T)
+        capacity = cls._get_type_arg_(Capacity)
+        return cls(0, alloc(Array[element_type, capacity]))
+
+    def size(self) -> int:
+        return self._size
+
+    @classmethod
+    def capacity(cls) -> int:
+        return cls._get_type_arg_(Capacity)
+
+    def is_full(self) -> bool:
+        return self._size == self.capacity()
+
+    def __getitem__(self, item) -> T:
+        return self._array[item]
+
+    def __setitem__(self, key: int, value: T):
+        self._array[key] = value
+
+    def append(self, value: T):
+        """Appends a copy of the given value to the end of the array."""
+        assert self._size < self._array.size()
+        self._array[self._size] = value
+        self._size += 1
+
+    def extend(self, values: ArrayLike[T]):
+        """Appends copies of the values in the given array to the end of the array."""
+        for value in values:
+            self.append(value)
+
+    def pop(self, index: int | None = None) -> T:
+        """Removes and returns a copy of the value at the given index.
+
+        Preserves the relative order of the elements.
+        """
+        if index is None:
+            index = self._size - 1
+        assert 0 <= index < self._size
+        value = copy(self._array[index])
+        self._size -= 1
+        if index < self._size:
+            for i in Range(index, self._size):
+                self._array[i] = self._array[i + 1]
+        return value
+
+    def insert(self, index: int, value: T):
+        """Inserts a copy of the given value at the given index.
+
+        Preserves the relative order of the elements.
+        """
+        assert 0 <= index <= self._size
+        assert self._size < self._array.size()
+        self._size += 1
+        for i in Range(self._size - 1, index, -1):
+            self._array[i] = self._array[i - 1]
+        self._array[index] = value
+
+    def remove(self, value: T) -> bool:
+        """Removes the first occurrence of the given value, returning whether the value was removed.
+
+        Preserves the relative order of the elements.
+        """
+        index = self.index_of(value)
+        if index < 0:
+            return False
+        self.pop(index)
+        return True
+
+    def clear(self):
+        """Sets size to zero."""
+        self._size = 0
+
+    def set_add(self, value: T) -> bool:
+        """Adds a copy of the given value if it is not already present, returning whether the value was added.
+
+        If the value is already present, the array is not modified.
+        If the array is full, the value is not added.
+        """
+        if self._size >= self._array.size():
+            return False
+        if value in self:
+            return False
+        self.append(value)
+        return True
+
+    def set_remove(self, value: T) -> bool:
+        """Removes the first occurrence of the given value, returning whether the value was removed.
+
+        Does not preserve the relative order of the elements.
+        """
+        index = self.index_of(value)
+        if index < 0:
+            return False
+        if index < self._size - 1:
+            self._array[index] = self._array[self._size - 1]
+        self._size -= 1
+        return True
+
+    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):
+        raise TypeError("unhashable type: 'VarArray'")
+
+
+class ArrayMapEntry[K, V](Record):
+    key: K
+    value: V
+
+
+class ArrayMap[K, V, Capacity](Record):
+    _size: int
+    _array: Array[ArrayMapEntry[K, V], Capacity]
+
+    @classmethod
+    def new(cls):
+        key_type = cls._get_type_arg_(K)
+        value_type = cls._get_type_arg_(V)
+        capacity = cls._get_type_arg_(Capacity)
+        return cls(0, alloc(Array[ArrayMapEntry[key_type, value_type], capacity]))
+
+    def size(self) -> int:
+        return self._size
+
+    @classmethod
+    def capacity(cls) -> int:
+        return cls._get_type_arg_(Capacity)
+
+    def is_full(self) -> bool:
+        return self._size == self.capacity()
+
+    def keys(self) -> SonolusIterator[K]:
+        return _ArrayMapKeyIterator(self, 0)
+
+    def values(self) -> SonolusIterator[V]:
+        return ArrayMapValueIterator(self, 0)
+
+    def items(self) -> SonolusIterator[tuple[K, V]]:
+        return ArrayMapEntryIterator(self, 0)
+
+    def __getitem__(self, key: K) -> V:
+        for i in Range(self._size):
+            entry = self._array[i]
+            if entry.key == key:
+                return entry.value
+        error()
+
+    def __setitem__(self, key: K, value: V):
+        for i in Range(self._size):
+            entry = self._array[i]
+            if entry.key == key:
+                entry.value = value
+                return
+        # assert self._size < self.capacity()
+        self._array[self._size] = ArrayMapEntry(key, value)
+        self._size += 1
+
+    def __contains__(self, key: K) -> bool:
+        for i in Range(self._size):  # noqa: SIM110
+            if self._array[i].key == key:
+                return True
+        return False
+
+    def pop(self, key: K) -> V:
+        for i in Range(self._size):
+            entry = self._array[i]
+            if entry.key == key:
+                value = copy(entry.value)
+                self._size -= 1
+                if i < self._size:
+                    self._array[i] = self._array[self._size]
+                return value
+        error()
+
+    def clear(self):
+        self._size = 0
+
+
+class _ArrayMapKeyIterator[K, V, Capacity](Record, SonolusIterator):
+    _map: ArrayMap[K, V, Capacity]
+    _index: int
+
+    def has_next(self) -> bool:
+        return self._index < self._map.size()
+
+    def next(self) -> K:
+        key = self._map._array[self._index].key
+        self._index += 1
+        return key
+
+
+class ArrayMapValueIterator[K, V, Capacity](Record, SonolusIterator):
+    _map: ArrayMap[K, V, Capacity]
+    _index: int
+
+    def has_next(self) -> bool:
+        return self._index < self._map.size()
+
+    def next(self) -> V:
+        value = self._map._array[self._index].value
+        self._index += 1
+        return value
+
+
+class ArrayMapEntryIterator[K, V, Capacity](Record, SonolusIterator):
+    _map: ArrayMap[K, V, Capacity]
+    _index: int
+
+    def has_next(self) -> bool:
+        return self._index < self._map.size()
+
+    def next(self) -> tuple[K, V]:
+        entry = self._map._array[self._index]
+        self._index += 1
+        return entry.key, entry.value

sonolus/script/debug.py

@@ -0,0 +1,70 @@
+from collections.abc import Callable
+from typing import Any, Never
+
+from sonolus.backend.flow import cfg_to_mermaid
+from sonolus.backend.mode import Mode
+from sonolus.backend.ops import Op
+from sonolus.backend.simplify import CoalesceFlow
+from sonolus.script.comptime import Comptime
+from sonolus.script.internal.context import GlobalContextState, ctx, set_ctx
+from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.internal.native import native_function
+from sonolus.script.num import Num
+from sonolus.script.values import with_default
+
+
+@meta_fn
+def error(message: str | None = None) -> None:
+    message = Comptime._accept_(message)._as_py_() if message is not None else "Error"
+    if not isinstance(message, str):
+        raise ValueError("Expected a string")
+    if ctx():
+        debug_log(ctx().map_constant(message))
+        debug_pause()
+        terminate()
+    else:
+        raise RuntimeError(message)
+
+
+@native_function(Op.DebugLog)
+def debug_log(value: Num):
+    print(f"[DEBUG] {value}")
+
+
+@native_function(Op.DebugPause)
+def debug_pause():
+    input("[DEBUG] Paused")
+
+
+def assert_true(value: Num, message: str | None = None):
+    message = with_default(message, "Assertion failed")
+    if not value:
+        error(message)
+
+
+def assert_false(value: Num, message: str | None = None):
+    message = with_default(message, "Assertion failed")
+    if value:
+        error(message)
+
+
+@meta_fn
+def assert_unreachable(message: str | None = None) -> Never:
+    message = validate_value(message)._as_py_() or "Unreachable code reached"
+    raise RuntimeError(message)
+
+
+@meta_fn
+def terminate():
+    if ctx():
+        set_ctx(ctx().into_dead())
+    else:
+        raise RuntimeError("Terminated")
+
+
+def visualize_cfg(fn: Callable[[], Any]) -> str:
+    from sonolus.build.compile import callback_to_cfg
+
+    cfg = callback_to_cfg(GlobalContextState(Mode.Play), fn, "")
+    cfg = CoalesceFlow().run(cfg)
+    return cfg_to_mermaid(cfg)

sonolus/script/effect.py

@@ -0,0 +1,132 @@
+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.internal.introspection import get_field_specifiers
+from sonolus.script.internal.native import native_function
+from sonolus.script.record import Record
+
+
+class Effect(Record):
+    id: int
+
+    def is_available(self) -> bool:
+        return _has_effect_clip(self.id)
+
+    def play(self, distance: float) -> None:
+        _play(self.id, distance)
+
+    def schedule(self, time: float, distance: float) -> None:
+        _play_scheduled(self.id, time, distance)
+
+    def loop(self) -> LoopedEffectHandle:
+        return LoopedEffectHandle(_play_looped(self.id))
+
+    def schedule_loop(self, start_time: float) -> ScheduledLoopedEffectHandle:
+        return ScheduledLoopedEffectHandle(_play_looped_scheduled(self.id, start_time))
+
+
+class LoopedEffectHandle(Record):
+    id: int
+
+    def stop(self) -> None:
+        _stop_looped(self.id)
+
+
+class ScheduledLoopedEffectHandle(Record):
+    id: int
+
+    def stop(self, end_time: float) -> None:
+        _stop_looped_scheduled(self.id, end_time)
+
+
+@native_function(Op.HasEffectClip)
+def _has_effect_clip(effect_id: int) -> bool:
+    raise NotImplementedError
+
+
+@native_function(Op.Play)
+def _play(effect_id: int, distance: float) -> None:
+    raise NotImplementedError
+
+
+@native_function(Op.PlayLooped)
+def _play_looped(effect_id: int) -> int:
+    raise NotImplementedError
+
+
+@native_function(Op.PlayLoopedScheduled)
+def _play_looped_scheduled(effect_id: int, start_time: float) -> int:
+    raise NotImplementedError
+
+
+@native_function(Op.PlayScheduled)
+def _play_scheduled(effect_id: int, time: float, distance: float) -> None:
+    raise NotImplementedError
+
+
+@native_function(Op.StopLooped)
+def _stop_looped(handle: int) -> None:
+    raise NotImplementedError
+
+
+@native_function(Op.StopLoopedScheduled)
+def _stop_looped_scheduled(handle: int, end_time: float) -> None:
+    raise NotImplementedError
+
+
+@dataclass
+class EffectInfo:
+    name: str
+
+
+def effect(name: str) -> Any:
+    return EffectInfo(name)
+
+
+class Effects(Protocol):
+    _effects_: list[str]
+
+
+@dataclass_transform()
+def effects[T](cls: type[T]) -> T | Effects:
+    if len(cls.__bases__) != 1:
+        raise ValueError("Effects 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 effects: {annotation}")
+        annotation_type = annotation.__args__[0]
+        annotation_values = annotation.__metadata__
+        if annotation_type is not Effect:
+            raise TypeError(f"Invalid annotation for effects: {annotation}, expected annotation of type Effect")
+        if len(annotation_values) != 1 or not isinstance(annotation_values[0], EffectInfo):
+            raise TypeError(f"Invalid annotation for effects: {annotation}, expected a single string annotation value")
+        effect_name = annotation_values[0].name
+        names.append(effect_name)
+        setattr(instance, name, Effect(i))
+    instance._effects_ = names
+    instance._is_comptime_value_ = True
+    return instance
+
+
+class StandardEffect:
+    Miss = Annotated[Effect, effect("#MISS")]
+    Perfect = Annotated[Effect, effect("#PERFECT")]
+    Great = Annotated[Effect, effect("#GREAT")]
+    Good = Annotated[Effect, effect("#GOOD")]
+    Hold = Annotated[Effect, effect("#HOLD")]
+    MissAlternative = Annotated[Effect, effect("#MISS_ALTERNATIVE")]
+    PerfectAlternative = Annotated[Effect, effect("#PERFECT_ALTERNATIVE")]
+    GreatAlternative = Annotated[Effect, effect("#GREAT_ALTERNATIVE")]
+    GoodAlternative = Annotated[Effect, effect("#GOOD_ALTERNATIVE")]
+    HoldAlternative = Annotated[Effect, effect("#HOLD_ALTERNATIVE")]
+    Stage = Annotated[Effect, effect("#STAGE")]
+
+
+@effects
+class EmptyEffects:
+    pass

sonolus/script/engine.py

@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from sonolus.build.collection import Asset
+from sonolus.script.archetype import BaseArchetype
+from sonolus.script.bucket import Buckets, EmptyBuckets
+from sonolus.script.effect import Effects, EmptyEffects
+from sonolus.script.options import EmptyOptions, Options
+from sonolus.script.particle import EmptyParticles, Particles
+from sonolus.script.sprite import EmptySkin, Skin
+from sonolus.script.ui import UiConfig
+
+
+class Engine:
+    version = 12
+
+    def __init__(
+        self,
+        *,
+        name: str,
+        title: str | None = None,
+        subtitle: str = "Sonolus.py Engine",
+        author: str = "Unknown",
+        skin: str | None = None,
+        background: str | None = None,
+        effect: str | None = None,
+        particle: str | None = None,
+        thumbnail: Asset | None = None,
+        data: EngineData,
+    ) -> None:
+        self.name = name
+        self.title = title or name
+        self.subtitle = subtitle
+        self.author = author
+        self.skin = skin
+        self.background = background
+        self.effect = effect
+        self.particle = particle
+        self.thumbnail = thumbnail
+        self.data = data
+
+
+def default_callback() -> float:
+    return 0.0
+
+
+class PlayMode:
+    def __init__(
+        self,
+        *,
+        archetypes: list[type[BaseArchetype]] | None = None,
+        skin: Skin = EmptySkin,
+        effects: Effects = EmptyEffects,
+        particles: Particles = EmptyParticles,
+        buckets: Buckets = EmptyBuckets,
+    ) -> None:
+        self.archetypes = archetypes or []
+        self.skin = skin
+        self.effects = effects
+        self.particles = particles
+        self.buckets = buckets
+
+
+class WatchMode:
+    def __init__(
+        self,
+        *,
+        archetypes: list[type[BaseArchetype]] | None = None,
+        skin: Skin = EmptySkin,
+        effects: Effects = EmptyEffects,
+        particles: Particles = EmptyParticles,
+        buckets: Buckets = EmptyBuckets,
+        update_spawn: Callable[[], float],
+    ) -> None:
+        self.archetypes = archetypes or []
+        self.skin = skin
+        self.effects = effects
+        self.particles = particles
+        self.buckets = buckets
+        self.update_spawn = update_spawn
+
+
+class EngineData:
+    ui: UiConfig
+    options: Options
+    play: PlayMode
+    watch: WatchMode
+
+    def __init__(
+        self,
+        *,
+        ui: UiConfig | None = None,
+        options: Options = EmptyOptions,
+        play: PlayMode | None = None,
+        watch: WatchMode | None = None,
+    ) -> None:
+        self.ui = ui or UiConfig()
+        self.options = options
+        self.play = play or PlayMode()
+        self.watch = watch or WatchMode(update_spawn=default_callback)