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

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/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

@@ -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

@@ -138,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,35 +68,94 @@ 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):
+def flatten_entities(entities: EntityListArg) -> Iterator[PlayArchetype]:
     """Flatten a list of entities.
 
     Args:
         entities: The list of entities.
 
-    Returns:
-        The flattened list of entities.
+    Yields:
+        The flattened entities.
     """
     if isinstance(entities, list):
         for entity in entities:

sonolus/script/metadata.py

@@ -0,0 +1,32 @@
+from typing import Any
+
+type LocalizationText = dict[str, str]
+type AnyText = str | LocalizationText
+
+
+def as_localization_text(text: AnyText) -> LocalizationText:
+    if isinstance(text, str):
+        return {"en": text}
+    return text
+
+
+class Tag:
+    """A tag for an engine or level.
+
+    Args:
+        title: The title of the tag.
+        icon: The icon of the tag.
+    """
+
+    title: LocalizationText
+    icon: str | None
+
+    def __init__(self, title: AnyText, icon: str | None = None) -> None:
+        self.title = as_localization_text(title)
+        self.icon = icon
+
+    def as_dict(self) -> dict[str, Any]:
+        result = {"title": self.title}
+        if self.icon is not None:
+            result["icon"] = self.icon
+        return result

sonolus/script/num.py

@@ -134,6 +134,15 @@ class _Num(Value, metaclass=_NumMeta):
         else:
             return Num(-1)
 
+    @classmethod
+    def _zero_(cls) -> Self:
+        if ctx():
+            result_place = ctx().alloc(size=1)
+            ctx().add_statements(IRSet(result_place, IRConst(0)))
+            return cls(result_place)
+        else:
+            return cls(0)
+
     def ir(self):
         if isinstance(self.data, BlockPlace):
             return IRGet(self.data)

sonolus/script/options.py

@@ -69,7 +69,7 @@ class _SelectOption:
     standard: bool
     advanced: bool
     scope: str | None
-    default: str
+    default: int
     values: list[str]
 
     def to_dict(self):
@@ -78,7 +78,7 @@ class _SelectOption:
             "name": self.name,
             "standard": self.standard,
             "advanced": self.advanced,
-            "def": self.values.index(self.default),
+            "def": self.default,
             "values": self.values,
         }
         if self.scope is not None:
@@ -139,7 +139,7 @@ def select_option(
     name: str | None = None,
     standard: bool = False,
     advanced: bool = False,
-    default: str,
+    default: str | int,
     values: list[str],
     scope: str | None = None,
 ) -> Any:
@@ -153,6 +153,8 @@ def select_option(
         values: The values of the option.
         scope: The scope of the option.
     """
+    if isinstance(default, str):
+        default = values.index(default)
     return _SelectOption(name, standard, advanced, scope, default, values)
 
 

sonolus/script/pointer.py

@@ -1,4 +1,5 @@
 from sonolus.backend.place import BlockPlace
+from sonolus.script.internal.context import ctx
 from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.value import Value
 from sonolus.script.num import Num, _is_num
@@ -13,6 +14,7 @@ def _deref[T: Value](block: Num, offset: Num, type_: type[T]) -> T:
         block = block._as_py_()
         if not isinstance(block, int):
             raise TypeError("block must be an integer")
+        block = ctx().blocks(block)
     else:
         if not _is_num(block):
             raise TypeError("block must be a Num")

sonolus/script/project.py

@@ -1,9 +1,13 @@
 from __future__ import annotations
 
+from collections.abc import Sequence
+from dataclasses import dataclass
 from os import PathLike
 from pathlib import Path
-from typing import Self, TypedDict
+from typing import ClassVar, Self, TypedDict
 
+from sonolus.backend.optimize import optimize
+from sonolus.backend.optimize.passes import CompilerPass
 from sonolus.script.archetype import ArchetypeSchema
 from sonolus.script.engine import Engine
 from sonolus.script.level import Level
@@ -39,27 +43,30 @@ class Project:
         """
         return Project(self.engine, levels, self.resources)
 
-    def dev(self, build_dir: PathLike, port: int = 8080):
+    def dev(self, build_dir: PathLike, port: int = 8080, config: BuildConfig | None = None):
         """Start a development server for the project.
 
         Args:
             build_dir: The path to the build directory.
             port: The port of the development server.
+            config: The build configuration.
         """
         from sonolus.build.cli import build_collection, run_server
 
-        build_collection(self, Path(build_dir))
+        build_collection(self, Path(build_dir), config)
         run_server(Path(build_dir) / "site", port=port)
 
-    def build(self, build_dir: PathLike):
+    def build(self, build_dir: PathLike, config: BuildConfig | None = None):
         """Build the project.
 
         Args:
             build_dir: The path to the build directory.
+            config: The build configuration.
         """
         from sonolus.build.cli import build_project
 
-        build_project(self, Path(build_dir))
+        config = config or BuildConfig()
+        build_project(self, Path(build_dir), config)
 
     def schema(self) -> ProjectSchema:
         """Generate the schema of the project.
@@ -74,3 +81,32 @@ class Project:
 
 class ProjectSchema(TypedDict):
     archetypes: list[ArchetypeSchema]
+
+
+@dataclass
+class BuildConfig:
+    """A configuration for building an engine package."""
+
+    MINIMAL_PASSES: ClassVar[Sequence[CompilerPass]] = optimize.MINIMAL_PASSES
+    """The minimal list of compiler passes."""
+
+    FAST_PASSES: ClassVar[Sequence[CompilerPass]] = optimize.FAST_PASSES
+    """The list of compiler passes for faster builds."""
+
+    STANDARD_PASSES: ClassVar[Sequence[CompilerPass]] = optimize.STANDARD_PASSES
+    """The standard list of compiler passes."""
+
+    passes: Sequence[CompilerPass] = optimize.STANDARD_PASSES
+    """The list of compiler passes to use."""
+
+    build_play: bool = True
+    """Whether to build the play package."""
+
+    build_watch: bool = True
+    """Whether to build the watch package."""
+
+    build_preview: bool = True
+    """Whether to build the preview package."""
+
+    build_tutorial: bool = True
+    """Whether to build the tutorial package."""

sonolus/script/record.py

@@ -206,8 +206,7 @@ class Record(GenericValue):
         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")
+        value = self._accept_(value)
         for field in self._fields:
             field.__set__(self, field.__get__(value))
 
@@ -221,6 +220,12 @@ class Record(GenericValue):
         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}
+        return result
+
     def __str__(self):
         return (
             f"{self.__class__.__name__}({", ".join(f"{field.name}={field.__get__(self)}" for field in self._fields)})"

sonolus/script/runtime.py

@@ -103,6 +103,12 @@ class _PreviewRuntimeCanvas:
     scroll_direction: ScrollDirection
     size: float
 
+    def update(self, scroll_direction: ScrollDirection | None = None, size: float | None = None):
+        if scroll_direction is not None:
+            self.scroll_direction = scroll_direction
+        if size is not None:
+            self.size = size
+
 
 class RuntimeUiConfig(Record):
     scale: float
@@ -253,36 +259,57 @@ class _TutorialRuntimeUi:
 
 
 class Touch(Record):
+    """Data of a touch event."""
+
     id: int
+    """The unique identifier of the touch."""
+
     started: bool
+    """Whether the touch has started this frame."""
+
     ended: bool
+    """Whether the touch has ended this frame."""
+
     time: float
+    """The time of the touch event.
+
+    May remain constant while there is no movement.
+    """
+
     start_time: float
+    """The time the touch started."""
+
     position: Vec2
+    """The current position of the touch."""
+
     start_position: Vec2
+    """The position the touch started."""
+
     delta: Vec2
+    """The change in position of the touch."""
+
     velocity: Vec2
+    """The velocity of the touch."""
+
     speed: float
+    """The speed of the touch's movement."""
+
     angle: float
+    """The angle of the touch's movement."""
 
     @property
-    def total_time(self) -> float:
-        return self.time - self.start_time
+    def prev_position(self) -> Vec2:
+        """The previous position of the touch."""
+        return self.position - self.delta
 
     @property
     def total_delta(self) -> Vec2:
+        """The total change in position of the touch."""
         return self.position - self.start_position
 
-    @property
-    def total_velocity(self) -> Vec2:
-        return self.total_delta / self.total_time if self.total_time > 0 else Vec2(0, 0)
-
-    @property
-    def total_speed(self) -> float:
-        return self.total_velocity.magnitude
-
     @property
     def total_angle(self) -> float:
+        """The total angle of the touch's movement."""
         return self.total_delta.angle
 
 
@@ -449,6 +476,30 @@ def is_debug() -> bool:
             return False
 
 
+@meta_fn
+def is_play() -> bool:
+    """Check if the game is running in play mode."""
+    return 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
+
+
+@meta_fn
+def is_watch() -> bool:
+    """Check if the game is running in watch mode."""
+    return 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
+
+
 @meta_fn
 def aspect_ratio() -> float:
     """Get the aspect ratio of the game."""