sonolus.py 0.1.8__py3-none-any.whl → 0.2.0__py3-none-any.whl

sonolus/script/engine.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
+import json
 from collections.abc import Callable
+from os import PathLike
+from pathlib import Path
 from typing import Any
 
-from sonolus.build.collection import Asset
+from sonolus.build.collection import Asset, load_asset
 from sonolus.script.archetype import PlayArchetype, PreviewArchetype, WatchArchetype, _BaseArchetype
 from sonolus.script.bucket import Buckets, EmptyBuckets
 from sonolus.script.effect import Effects, EmptyEffects
@@ -13,12 +16,52 @@ from sonolus.script.instruction import (
     TutorialInstructionIcons,
     TutorialInstructions,
 )
+from sonolus.script.metadata import AnyText, Tag, as_localization_text
 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 ExportedEngine:
+    """An exported Sonolus.py engine."""
+
+    def __init__(
+        self,
+        *,
+        item: dict,
+        thumbnail: bytes,
+        play_data: bytes,
+        watch_data: bytes,
+        preview_data: bytes,
+        tutorial_data: bytes,
+        rom: bytes | None = None,
+        configuration: bytes,
+    ) -> None:
+        self.item = item
+        self.thumbnail = thumbnail
+        self.play_data = play_data
+        self.watch_data = watch_data
+        self.preview_data = preview_data
+        self.tutorial_data = tutorial_data
+        self.rom = rom
+        self.configuration = configuration
+
+    def write_to_dir(self, path: PathLike):
+        """Write the exported engine to a directory."""
+        path = Path(path)
+        path.mkdir(parents=True, exist_ok=True)
+        (path / "item.json").write_text(json.dumps(self.item, ensure_ascii=False), encoding="utf-8")
+        (path / "thumbnail").write_bytes(self.thumbnail)
+        (path / "playData").write_bytes(self.play_data)
+        (path / "watchData").write_bytes(self.watch_data)
+        (path / "previewData").write_bytes(self.preview_data)
+        (path / "tutorialData").write_bytes(self.tutorial_data)
+        if self.rom is not None:
+            (path / "rom").write_bytes(self.rom)
+        (path / "configuration").write_bytes(self.configuration)
+
+
 class Engine:
     """A Sonolus.py engine.
 
@@ -33,6 +76,9 @@ class Engine:
         particle: The default particle for the engine.
         thumbnail: The thumbnail for the engine.
         data: The engine's modes and configurations.
+        tags: The tags of the engine.
+        description: The description of the engine.
+        meta: Additional metadata of the engine.
     """
 
     version = 12
@@ -41,26 +87,68 @@ class Engine:
         self,
         *,
         name: str,
-        title: str | None = None,
-        subtitle: str = "Sonolus.py Engine",
-        author: str = "Unknown",
+        title: AnyText | None = None,
+        subtitle: AnyText = "Sonolus.py Engine",
+        author: AnyText = "Unknown",
         skin: str | None = None,
         background: str | None = None,
         effect: str | None = None,
         particle: str | None = None,
         thumbnail: Asset | None = None,
         data: EngineData,
+        tags: list[Tag] | None = None,
+        description: AnyText | None = None,
+        meta: Any = None,
     ) -> None:
         self.name = name
-        self.title = title or name
-        self.subtitle = subtitle
-        self.author = author
+        self.title = as_localization_text(title or name)
+        self.subtitle = as_localization_text(subtitle)
+        self.author = as_localization_text(author)
         self.skin = skin
         self.background = background
         self.effect = effect
         self.particle = particle
         self.thumbnail = thumbnail
         self.data = data
+        self.tags = tags or []
+        self.description = as_localization_text(description) if description is not None else None
+        self.meta = meta
+
+    def export(self) -> ExportedEngine:
+        """Export the engine in a sonolus-pack compatible format.
+
+        Returns:
+            An exported engine.
+        """
+        from sonolus.build.engine import package_engine
+        from sonolus.build.project import BLANK_PNG
+
+        item = {
+            "version": self.version,
+            "title": self.title,
+            "subtitle": self.subtitle,
+            "author": self.author,
+            "tags": [tag.as_dict() for tag in self.tags],
+            "skin": self.skin,
+            "background": self.background,
+            "effect": self.effect,
+            "particle": self.particle,
+        }
+        packaged = package_engine(self.data)
+        if self.description is not None:
+            item["description"] = self.description
+        if self.meta is not None:
+            item["meta"] = self.meta
+        return ExportedEngine(
+            item=item,
+            thumbnail=load_asset(self.thumbnail) if self.thumbnail is not None else BLANK_PNG,
+            play_data=packaged.play_data,
+            watch_data=packaged.watch_data,
+            preview_data=packaged.preview_data,
+            tutorial_data=packaged.tutorial_data,
+            rom=packaged.rom,
+            configuration=packaged.configuration,
+        )
 
 
 def default_callback() -> Any:
@@ -190,6 +278,30 @@ class TutorialMode:
         self.update = update
 
 
+def empty_play_mode() -> PlayMode:
+    """Create an empty play mode."""
+    return PlayMode()
+
+
+def empty_watch_mode() -> WatchMode:
+    """Create an empty watch mode."""
+    return WatchMode(update_spawn=default_callback)
+
+
+def empty_preview_mode() -> PreviewMode:
+    """Create an empty preview mode."""
+    return PreviewMode()
+
+
+def empty_tutorial_mode() -> TutorialMode:
+    """Create an empty tutorial mode."""
+    return TutorialMode(
+        preprocess=default_callback,
+        navigate=default_callback,
+        update=default_callback,
+    )
+
+
 class EngineData:
     """A Sonolus.py engine's modes and configurations.
 
@@ -214,11 +326,7 @@ class EngineData:
     ) -> None:
         self.ui = ui or UiConfig()
         self.options = options
-        self.play = play or PlayMode()
-        self.watch = watch or WatchMode(update_spawn=default_callback)
-        self.preview = preview or PreviewMode()
-        self.tutorial = tutorial or TutorialMode(
-            preprocess=default_callback,
-            navigate=default_callback,
-            update=default_callback,
-        )
+        self.play = play or empty_play_mode()
+        self.watch = watch or empty_watch_mode()
+        self.preview = preview or empty_preview_mode()
+        self.tutorial = tutorial or empty_tutorial_mode()

sonolus/script/internal/builtin_impls.py

@@ -52,9 +52,11 @@ def _enumerate(iterable, start=0):
     from sonolus.backend.visitor import compile_and_call
 
     iterable = validate_value(iterable)
-    if not hasattr(iterable, "__iter__"):
+    if isinstance(iterable, TupleImpl):
+        return TupleImpl._accept_(tuple((start + i, value) for i, value in enumerate(iterable._as_py_(), start=start)))
+    elif not hasattr(iterable, "__iter__"):
         raise TypeError(f"'{type(iterable).__name__}' object is not iterable")
-    if isinstance(iterable, ArrayLike):
+    elif isinstance(iterable, ArrayLike):
         return compile_and_call(iterable._enumerate_, start)
     else:
         iterator = compile_and_call(iterable.__iter__)
@@ -232,10 +234,27 @@ _int._type_mapping_ = Num
 _float._type_mapping_ = Num
 _bool._type_mapping_ = Num
 
+
+def _any(iterable):
+    for value in iterable:  # noqa: SIM110
+        if value:
+            return True
+    return False
+
+
+def _all(iterable):
+    for value in iterable:  # noqa: SIM110
+        if not value:
+            return False
+    return True
+
+
 # classmethod, property, staticmethod are supported as decorators, but not within functions
 
 BUILTIN_IMPLS = {
     id(abs): _abs,
+    id(all): _all,
+    id(any): _any,
     id(bool): _bool,
     id(callable): _callable,
     id(enumerate): _enumerate,

sonolus/script/internal/constant.py

@@ -97,7 +97,7 @@ class ConstantValue(Value):
     def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
         return cls()
 
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         return []
 
     @classmethod
@@ -107,7 +107,7 @@ class ConstantValue(Value):
     def _get_(self) -> Self:
         return self
 
-    def _set_(self, value: Any) -> Self:
+    def _set_(self, value: Any):
         if value is not self:
             raise ValueError(f"{type(self).__name__} is immutable")
 
@@ -122,6 +122,10 @@ class ConstantValue(Value):
     def _alloc_(cls) -> Self:
         return cls()
 
+    @classmethod
+    def _zero_(cls) -> Self:
+        return cls()
+
     @meta_fn
     def __eq__(self, other):
         return self is other

sonolus/script/internal/context.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from contextlib import contextmanager
 from contextvars import ContextVar
 from dataclasses import dataclass
+from threading import Lock
 from typing import Any, Self
 
 from sonolus.backend.blocks import BlockData, PlayBlock
@@ -25,6 +26,7 @@ class GlobalContextState:
     environment_mappings: dict[_GlobalInfo, int]
     environment_offsets: dict[Block, int]
     mode: Mode
+    lock: Lock
 
     def __init__(self, mode: Mode, archetypes: dict[type, int] | None = None, rom: ReadOnlyMemory | None = None):
         self.archetypes = archetypes or {}
@@ -33,6 +35,7 @@ class GlobalContextState:
         self.environment_mappings = {}
         self.environment_offsets = {}
         self.mode = mode
+        self.lock = Lock()
 
 
 class CallbackContextState:
@@ -88,10 +91,6 @@ class Context:
     def used_names(self) -> dict[str, int]:
         return self.callback_state.used_names
 
-    @property
-    def const_mappings(self) -> dict[Any, int]:
-        return self.global_state.const_mappings
-
     def check_readable(self, place: BlockPlace):
         if not self.callback:
             return
@@ -204,22 +203,25 @@ class Context:
                         )
 
     def map_constant(self, value: Any) -> int:
-        if value not in self.const_mappings:
-            self.const_mappings[value] = len(self.const_mappings)
-        return self.const_mappings[value]
+        with self.global_state.lock:
+            const_mappings = self.global_state.const_mappings
+            if value not in const_mappings:
+                const_mappings[value] = len(const_mappings)
+            return const_mappings[value]
 
     def get_global_base(self, value: _GlobalInfo | _GlobalPlaceholder) -> BlockPlace:
-        block = value.blocks.get(self.global_state.mode)
-        if block is None:
-            raise RuntimeError(f"Global {value.name} is not available in '{self.global_state.mode.name}' mode")
-        if value not in self.global_state.environment_mappings:
-            if value.offset is None:
-                offset = self.global_state.environment_offsets.get(block, 0)
-                self.global_state.environment_mappings[value] = offset
-                self.global_state.environment_offsets[block] = offset + value.size
-            else:
-                self.global_state.environment_mappings[value] = value.offset
-        return BlockPlace(block, self.global_state.environment_mappings[value])
+        with self.global_state.lock:
+            block = value.blocks.get(self.global_state.mode)
+            if block is None:
+                raise RuntimeError(f"Global {value.name} is not available in '{self.global_state.mode.name}' mode")
+            if value not in self.global_state.environment_mappings:
+                if value.offset is None:
+                    offset = self.global_state.environment_offsets.get(block, 0)
+                    self.global_state.environment_mappings[value] = offset
+                    self.global_state.environment_offsets[block] = offset + value.size
+                else:
+                    self.global_state.environment_mappings[value] = value.offset
+            return BlockPlace(block, self.global_state.environment_mappings[value])
 
     @classmethod
     def meet(cls, contexts: list[Context]) -> Context:
@@ -257,19 +259,22 @@ def using_ctx(value: Context | None):
 class ReadOnlyMemory:
     values: list[float]
     indexes: dict[tuple[float, ...], int]
+    _lock: Lock
 
     def __init__(self):
         self.values = []
         self.indexes = {}
+        self._lock = Lock()
 
     def __getitem__(self, item: tuple[float, ...]) -> BlockPlace:
-        if item not in self.indexes:
-            index = len(self.values)
-            self.indexes[item] = index
-            self.values.extend(item)
-        else:
-            index = self.indexes[item]
-        return BlockPlace(self.block, index)
+        with self._lock:
+            if item not in self.indexes:
+                index = len(self.values)
+                self.indexes[item] = index
+                self.values.extend(item)
+            else:
+                index = self.indexes[item]
+            return BlockPlace(self.block, index)
 
     @property
     def block(self) -> Block:

sonolus/script/internal/introspection.py

@@ -12,6 +12,13 @@ def get_field_specifiers(cls, *, skip: set[str] = frozenset(), globals=None, loc
         if class_value is not _missing and key not in skip:
             results[key] = Annotated[value, class_value]
     for key, value in cls.__dict__.items():
-        if key not in results and key not in skip and not key.startswith("__") and not callable(value):
+        if (
+            key not in results
+            and key not in skip
+            and not key.startswith("__")
+            and not callable(value)
+            and not hasattr(value, "__func__")
+            and not isinstance(value, property)
+        ):
             raise ValueError(f"Missing annotation for {cls.__name__}.{key}")
     return results

sonolus/script/internal/math_impls.py

@@ -93,7 +93,8 @@ def _ln(x: float) -> float:
 def _log(x: float, base: float | None = None) -> float:
     if base is None:
         return _ln(x)
-    return _ln(x) / _ln(base)
+    else:
+        return _ln(x) / _ln(base)
 
 
 @native_function(Op.Rem)

sonolus/script/internal/transient.py

@@ -26,7 +26,7 @@ class TransientValue(Value):
     def _from_list_(cls, values: Iterable[float | BlockPlace]) -> Self:
         raise TypeError(f"{cls.__name__} cannot be constructed from list")
 
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         raise TypeError(f"{type(self).__name__} cannot be deconstructed to list")
 
     @classmethod
@@ -49,3 +49,7 @@ class TransientValue(Value):
     @classmethod
     def _alloc_(cls) -> Self:
         raise TypeError(f"{cls.__name__} is not allocatable")
+
+    @classmethod
+    def _zero_(cls) -> Self:
+        raise TypeError(f"{cls.__name__} does not have a zero value")

sonolus/script/internal/value.py

@@ -66,7 +66,7 @@ class Value:
         raise NotImplementedError
 
     @abstractmethod
-    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[float | str | BlockPlace]:
         """Converts this value to a list of floats."""
         raise NotImplementedError
 
@@ -76,7 +76,9 @@ class Value:
         """Returns the keys to a flat representation of this value."""
         raise NotImplementedError
 
-    def _to_flat_dict_(self, prefix: str, level_refs: dict[Any, int] | None = None) -> dict[str, float | BlockPlace]:
+    def _to_flat_dict_(
+        self, prefix: str, level_refs: dict[Any, str] | None = None
+    ) -> dict[str, float | str | BlockPlace]:
         """Converts this value to a flat dictionary."""
         return dict(zip(self._flat_keys_(prefix), self._to_list_(level_refs), strict=False))
 
@@ -136,6 +138,12 @@ class Value:
         """Allocates a new value which may be uninitialized."""
         raise NotImplementedError
 
+    @classmethod
+    @abstractmethod
+    def _zero_(cls) -> Self:
+        """Returns a zero-initialized value of this type."""
+        raise NotImplementedError
+
     def __imatmul__(self, other):
         self._copy_from_(other)
         return self

sonolus/script/interval.py

@@ -19,6 +19,22 @@ class Interval(Record):
     start: float
     end: float
 
+    @classmethod
+    def zero(cls) -> Self:
+        """Get an empty interval."""
+        return cls(0, 0)
+
+    def then(self, length: float) -> Self:
+        """Get the interval after this one with a given length.
+
+        Args:
+            length: The length of the interval.
+
+        Returns:
+            An interval that has the end of this interval as the start and has the given length.
+        """
+        return Interval(self.end, self.end + length)
+
     @property
     def length(self) -> float:
         """The length of the interval.

sonolus/script/iterator.py

@@ -165,3 +165,20 @@ class _FilteringIterator[T, Fn](Record, SonolusIterator):
 
     def advance(self):
         self.iterator.advance()
+
+
+class _ChainingIterator[T](Record, SonolusIterator):
+    iterator: T
+
+    def has_next(self) -> bool:
+        return self.iterator.has_next()
+
+    def get(self) -> Any:
+        return self.iterator.get().get()
+
+    def advance(self):
+        self.iterator.get().advance()
+        while not self.iterator.get().has_next():
+            self.iterator.advance()
+            if not self.iterator.has_next():
+                break

sonolus/script/level.py

@@ -1,7 +1,44 @@
 from __future__ import annotations
 
-from sonolus.build.collection import Asset
+import json
+from collections.abc import Iterator
+from os import PathLike
+from pathlib import Path
+from typing import Any
+
+from sonolus.build.collection import Asset, load_asset
 from sonolus.script.archetype import PlayArchetype, StandardArchetypeName, StandardImport
+from sonolus.script.metadata import AnyText, Tag, as_localization_text
+
+
+class ExportedLevel:
+    """An exported Sonolus level."""
+
+    def __init__(
+        self,
+        *,
+        item: dict,
+        cover: bytes,
+        bgm: bytes,
+        preview: bytes | None,
+        data: bytes,
+    ):
+        self.item = item
+        self.cover = cover
+        self.bgm = bgm
+        self.preview = preview
+        self.data = data
+
+    def write_to_dir(self, path: PathLike):
+        """Write the exported level to a directory."""
+        path = Path(path)
+        path.mkdir(parents=True, exist_ok=True)
+        (path / "item.json").write_text(json.dumps(self.item, ensure_ascii=False), encoding="utf-8")
+        (path / "cover").write_bytes(self.cover)
+        (path / "bgm").write_bytes(self.bgm)
+        if self.preview is not None:
+            (path / "preview").write_bytes(self.preview)
+        (path / "data").write_bytes(self.data)
 
 
 class Level:
@@ -16,6 +53,13 @@ class Level:
         cover: The cover of the level.
         bgm: The background music of the level.
         data: The data of the level.
+        use_skin: The skin to use, overriding the engine skin.
+        use_background: The background to use, overriding the engine background.
+        use_effect: The effect to use, overriding the engine effect.
+        use_particle: The particle to use, overriding the engine particle.
+        tags: The tags of the level.
+        description: The description of the level.
+        meta: Additional metadata of the level.
     """
 
     version = 1
@@ -24,22 +68,100 @@ class Level:
         self,
         *,
         name: str,
-        title: str | None = None,
+        title: AnyText | None = None,
         rating: int = 0,
-        artists: str = "Unknown",
-        author: str = "Unknown",
+        artists: AnyText = "Unknown",
+        author: AnyText = "Unknown",
         cover: Asset | None = None,
         bgm: Asset | None = None,
+        preview: Asset | None = None,
         data: LevelData,
+        use_skin: str | None = None,
+        use_background: str | None = None,
+        use_effect: str | None = None,
+        use_particle: str | None = None,
+        tags: list[Tag] | None = None,
+        description: AnyText | None = None,
+        meta: Any = None,
     ) -> None:
         self.name = name
-        self.title = title or name
+        self.title = as_localization_text(title or name)
         self.rating = rating
-        self.artists = artists
-        self.author = author
+        self.artists = as_localization_text(artists)
+        self.author = as_localization_text(author)
         self.cover = cover
         self.bgm = bgm
+        self.preview = preview
         self.data = data
+        self.use_skin = use_skin
+        self.use_background = use_background
+        self.use_effect = use_effect
+        self.use_particle = use_particle
+        self.tags = tags or []
+        self.description = as_localization_text(description) if description is not None else None
+        self.meta = meta
+
+    def export(self, engine_name: str) -> ExportedLevel:
+        """Export the level in a sonolus-pack compatible format.
+
+        Args:
+            engine_name: The name of the engine this level is for.
+
+        Returns:
+            The exported level.
+        """
+        from sonolus.build.level import package_level_data
+        from sonolus.build.project import BLANK_AUDIO, BLANK_PNG
+
+        item = {
+            "version": self.version,
+            "rating": self.rating,
+            "engine": engine_name,
+            "useSkin": {"useDefault": True} if self.use_skin is None else {"useDefault": False, "item": self.use_skin},
+            "useBackground": {"useDefault": True}
+            if self.use_background is None
+            else {"useDefault": False, "item": self.use_background},
+            "useEffect": {"useDefault": True}
+            if self.use_effect is None
+            else {"useDefault": False, "item": self.use_effect},
+            "useParticle": {"useDefault": True}
+            if self.use_particle is None
+            else {"useDefault": False, "item": self.use_particle},
+            "title": self.title,
+            "artists": self.artists,
+            "author": self.author,
+            "tags": [tag.as_dict() for tag in self.tags],
+        }
+        if self.description is not None:
+            item["description"] = self.description
+        if self.meta is not None:
+            item["meta"] = self.meta
+        return ExportedLevel(
+            item=item,
+            cover=load_asset(self.cover) if self.cover is not None else BLANK_PNG,
+            bgm=load_asset(self.bgm) if self.bgm is not None else BLANK_AUDIO,
+            preview=load_asset(self.preview) if self.preview is not None else None,
+            data=package_level_data(self.data),
+        )
+
+
+type EntityListArg = list[PlayArchetype | EntityListArg]
+
+
+def flatten_entities(entities: EntityListArg) -> Iterator[PlayArchetype]:
+    """Flatten a list of entities.
+
+    Args:
+        entities: The list of entities.
+
+    Yields:
+        The flattened entities.
+    """
+    if isinstance(entities, list):
+        for entity in entities:
+            yield from flatten_entities(entity)
+    else:
+        yield entities
 
 
 class LevelData:
@@ -55,7 +177,7 @@ class LevelData:
 
     def __init__(self, bgm_offset: float, entities: list[PlayArchetype]) -> None:
         self.bgm_offset = bgm_offset
-        self.entities = entities
+        self.entities = [*flatten_entities(entities)]
 
 
 class BpmChange(PlayArchetype):