sonolus.py 0.9.2__py3-none-any.whl → 0.10.0__py3-none-any.whl

sonolus/build/engine.py

@@ -24,7 +24,7 @@ from sonolus.script.internal.callbacks import (
     update_callback,
     update_spawn_callback,
 )
-from sonolus.script.internal.context import ReadOnlyMemory
+from sonolus.script.internal.context import ProjectContextState, ReadOnlyMemory
 from sonolus.script.options import Options
 from sonolus.script.particle import Particles
 from sonolus.script.project import BuildConfig
@@ -69,12 +69,14 @@ def package_engine(
     engine: EngineData,
     config: BuildConfig | None = None,
     cache: CompileCache | None = None,
+    project_state: ProjectContextState | None = None,
 ):
     if cache is None:
         cache = CompileCache()
 
     config = config or BuildConfig()
-    rom = ReadOnlyMemory()
+    if project_state is None:
+        project_state = ProjectContextState()
     configuration = build_engine_configuration(engine.options, engine.ui)
     if no_gil():
         # process_cpu_count is available in Python 3.13+
@@ -99,7 +101,7 @@ def package_engine(
                 effects=play_mode.effects,
                 particles=play_mode.particles,
                 buckets=play_mode.buckets,
-                rom=rom,
+                project_state=project_state,
                 config=config,
                 thread_pool=thread_pool,
                 cache=cache,
@@ -111,7 +113,7 @@ def package_engine(
                 effects=watch_mode.effects,
                 particles=watch_mode.particles,
                 buckets=watch_mode.buckets,
-                rom=rom,
+                project_state=project_state,
                 update_spawn=watch_mode.update_spawn,
                 config=config,
                 thread_pool=thread_pool,
@@ -121,7 +123,7 @@ def package_engine(
                 build_preview_mode,
                 archetypes=preview_mode.archetypes,
                 skin=preview_mode.skin,
-                rom=rom,
+                project_state=project_state,
                 config=config,
                 thread_pool=thread_pool,
                 cache=cache,
@@ -136,7 +138,7 @@ def package_engine(
                 preprocess=tutorial_mode.preprocess,
                 navigate=tutorial_mode.navigate,
                 update=tutorial_mode.update,
-                rom=rom,
+                project_state=project_state,
                 config=config,
                 thread_pool=thread_pool,
                 cache=cache,
@@ -154,7 +156,7 @@ def package_engine(
             effects=play_mode.effects,
             particles=play_mode.particles,
             buckets=play_mode.buckets,
-            rom=rom,
+            project_state=project_state,
             config=config,
             thread_pool=None,
             cache=cache,
@@ -165,7 +167,7 @@ def package_engine(
             effects=watch_mode.effects,
             particles=watch_mode.particles,
             buckets=watch_mode.buckets,
-            rom=rom,
+            project_state=project_state,
             update_spawn=watch_mode.update_spawn,
             config=config,
             thread_pool=None,
@@ -174,7 +176,7 @@ def package_engine(
         preview_data = build_preview_mode(
             archetypes=preview_mode.archetypes,
             skin=preview_mode.skin,
-            rom=rom,
+            project_state=project_state,
             config=config,
             thread_pool=None,
             cache=cache,
@@ -188,7 +190,7 @@ def package_engine(
             preprocess=tutorial_mode.preprocess,
             navigate=tutorial_mode.navigate,
             update=tutorial_mode.update,
-            rom=rom,
+            project_state=project_state,
             config=config,
             thread_pool=None,
             cache=cache,
@@ -200,7 +202,7 @@ def package_engine(
         watch_data=package_data(watch_data),
         preview_data=package_data(preview_data),
         tutorial_data=package_data(tutorial_data),
-        rom=package_rom(rom),
+        rom=package_rom(project_state.rom),
     )
 
 
@@ -209,7 +211,7 @@ def validate_engine(
     config: BuildConfig | None = None,
 ):
     config = config or BuildConfig()
-    rom = ReadOnlyMemory()
+    project_state = ProjectContextState()
 
     play_mode = engine.play if config.build_play else empty_play_mode()
     watch_mode = engine.watch if config.build_watch else empty_watch_mode()
@@ -222,7 +224,7 @@ def validate_engine(
         effects=play_mode.effects,
         particles=play_mode.particles,
         buckets=play_mode.buckets,
-        rom=rom,
+        project_state=project_state,
         config=config,
         thread_pool=None,
         validate_only=True,
@@ -233,7 +235,7 @@ def validate_engine(
         effects=watch_mode.effects,
         particles=watch_mode.particles,
         buckets=watch_mode.buckets,
-        rom=rom,
+        project_state=project_state,
         update_spawn=watch_mode.update_spawn,
         config=config,
         thread_pool=None,
@@ -242,7 +244,7 @@ def validate_engine(
     build_preview_mode(
         archetypes=preview_mode.archetypes,
         skin=preview_mode.skin,
-        rom=rom,
+        project_state=project_state,
         config=config,
         thread_pool=None,
         validate_only=True,
@@ -256,7 +258,7 @@ def validate_engine(
         preprocess=tutorial_mode.preprocess,
         navigate=tutorial_mode.navigate,
         update=tutorial_mode.update,
-        rom=rom,
+        project_state=project_state,
         config=config,
         thread_pool=None,
         validate_only=True,
@@ -279,7 +281,7 @@ def build_play_mode(
     effects: Effects,
     particles: Particles,
     buckets: Buckets,
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
@@ -288,7 +290,7 @@ def build_play_mode(
     return {
         **compile_mode(
             mode=Mode.PLAY,
-            rom=rom,
+            project_state=project_state,
             archetypes=archetypes,
             global_callbacks=None,
             passes=config.passes,
@@ -309,7 +311,7 @@ def build_watch_mode(
     effects: Effects,
     particles: Particles,
     buckets: Buckets,
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     update_spawn: Callable[[], float],
     config: BuildConfig,
     thread_pool: Executor | None = None,
@@ -319,7 +321,7 @@ def build_watch_mode(
     return {
         **compile_mode(
             mode=Mode.WATCH,
-            rom=rom,
+            project_state=project_state,
             archetypes=archetypes,
             global_callbacks=[(update_spawn_callback, update_spawn)],
             passes=config.passes,
@@ -337,7 +339,7 @@ def build_watch_mode(
 def build_preview_mode(
     archetypes: list[type[_BaseArchetype]],
     skin: Skin,
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
@@ -346,7 +348,7 @@ def build_preview_mode(
     return {
         **compile_mode(
             mode=Mode.PREVIEW,
-            rom=rom,
+            project_state=project_state,
             archetypes=archetypes,
             global_callbacks=None,
             passes=config.passes,
@@ -367,7 +369,7 @@ def build_tutorial_mode(
     preprocess: Callable[[], None],
     navigate: Callable[[], None],
     update: Callable[[], None],
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
@@ -376,7 +378,7 @@ def build_tutorial_mode(
     return {
         **compile_mode(
             mode=Mode.TUTORIAL,
-            rom=rom,
+            project_state=project_state,
             archetypes=[],
             global_callbacks=[
                 (preprocess_callback, preprocess),

sonolus/build/project.py

@@ -7,6 +7,7 @@ from sonolus.build.compile import CompileCache
 from sonolus.build.engine import package_engine, unpackage_data
 from sonolus.build.level import package_level_data
 from sonolus.script.engine import Engine
+from sonolus.script.internal.context import ProjectContextState
 from sonolus.script.level import ExternalLevelData, ExternalLevelDataDict, Level, LevelData, parse_external_level_data
 from sonolus.script.project import BuildConfig, Project, ProjectSchema
 
@@ -21,7 +22,10 @@ BLANK_AUDIO = (
 
 
 def build_project_to_collection(
-    project: Project, config: BuildConfig | None, cache: CompileCache | None = None
+    project: Project,
+    config: BuildConfig | None,
+    cache: CompileCache | None = None,
+    project_state: ProjectContextState | None = None,
 ) -> Collection:
     collection = load_resources_files_to_collection(project.resources)
     for src_engine, converter in project.converters.items():
@@ -34,7 +38,7 @@ def build_project_to_collection(
     if config.override_resource_level_engines:
         for level in collection.categories.get("levels", {}).values():
             level["item"]["engine"] = project.engine.name
-    add_engine_to_collection(collection, project, project.engine, config, cache=cache)
+    add_engine_to_collection(collection, project, project.engine, config, cache=cache, project_state=project_state)
     for level in project.levels:
         add_level_to_collection(collection, project, level)
     collection.name = f"{project.engine.name}"
@@ -72,8 +76,9 @@ def add_engine_to_collection(
     engine: Engine,
     config: BuildConfig | None,
     cache: CompileCache | None = None,
+    project_state: ProjectContextState | None = None,
 ):
-    packaged_engine = package_engine(engine.data, config, cache=cache)
+    packaged_engine = package_engine(engine.data, config, cache=cache, project_state=project_state)
     item = {
         "name": engine.name,
         "version": engine.version,

sonolus/script/archetype.py

@@ -207,7 +207,7 @@ class _IsScoredDescriptor(SonolusDescriptor):
         if instance is None:
             return self.value
         elif ctx():
-            return ctx().global_state.is_scored_by_archetype_id[instance.id]
+            return ctx().mode_state.is_scored_by_archetype_id[instance.id]
         else:
             return self.value
 
@@ -220,7 +220,7 @@ class _IdDescriptor(SonolusDescriptor):
         if not ctx():
             raise RuntimeError("Archetype id is only available during compilation")
         if instance is None:
-            result = ctx().global_state.archetypes.get(owner)
+            result = ctx().mode_state.archetypes.get(owner)
             if result is None:
                 raise RuntimeError("Archetype is not registered")
             return result
@@ -237,7 +237,7 @@ class _KeyDescriptor(SonolusDescriptor):
 
     def __get__(self, instance, owner):
         if instance is not None and ctx():
-            return ctx().global_state.keys_by_archetype_id[instance.id]
+            return ctx().mode_state.keys_by_archetype_id[instance.id]
         else:
             return self.value
 
@@ -249,8 +249,8 @@ class _ArchetypeLifeDescriptor(SonolusDescriptor):
     def __get__(self, instance, owner):
         if not ctx():
             raise RuntimeError("Archetype life is only available during compilation")
-        if ctx().global_state.mode not in {Mode.PLAY, Mode.WATCH}:
-            raise RuntimeError(f"Archetype life is not available in mode '{ctx().global_state.mode.value}'")
+        if ctx().mode_state.mode not in {Mode.PLAY, Mode.WATCH}:
+            raise RuntimeError(f"Archetype life is not available in mode '{ctx().mode_state.mode.value}'")
         if instance is not None:
             return _deref(ctx().blocks.ArchetypeLife, instance.id * ArchetypeLife._size_(), ArchetypeLife)
         else:
@@ -1115,7 +1115,7 @@ def get_archetype_by_name(name: str) -> AnyArchetype:
     name = name._as_py_()  # type: ignore
     if not isinstance(name, str):
         raise TypeError(f"Invalid name: '{name}'")
-    archetypes_by_name = ctx().global_state.archetypes_by_name
+    archetypes_by_name = ctx().mode_state.archetypes_by_name
     if name not in archetypes_by_name:
         raise KeyError(f"Unknown archetype: '{name}'")
     return archetypes_by_name[name]  # type: ignore
@@ -1129,7 +1129,7 @@ def entity_info_at(index: int) -> PlayEntityInfo | WatchEntityInfo | PreviewEnti
     """
     if not ctx():
         raise RuntimeError("Calling entity_info_at is only allowed within a callback")
-    match ctx().global_state.mode:
+    match ctx().mode_state.mode:
         case Mode.PLAY:
             return _deref(ctx().blocks.EntityInfoArray, index * PlayEntityInfo._size_(), PlayEntityInfo)
         case Mode.WATCH:
@@ -1137,7 +1137,7 @@ def entity_info_at(index: int) -> PlayEntityInfo | WatchEntityInfo | PreviewEnti
         case Mode.PREVIEW:
             return _deref(ctx().blocks.EntityInfoArray, index * PreviewEntityInfo._size_(), PreviewEntityInfo)
         case _:
-            raise RuntimeError(f"Entity info is not available in mode '{ctx().global_state.mode}'")
+            raise RuntimeError(f"Entity info is not available in mode '{ctx().mode_state.mode}'")
 
 
 class PlayEntityInfo(Record):

sonolus/script/bucket.py

@@ -156,7 +156,7 @@ class Bucket(Record):
         """The judgment window of the bucket."""
         if not ctx():
             raise RuntimeError("Bucket window access outside of compilation")
-        match ctx().global_state.mode:
+        match ctx().mode_state.mode:
             case Mode.PLAY:
                 return _deref(ctx().blocks.LevelBucket, self.id * JudgmentWindow._size_(), JudgmentWindow)
             case Mode.WATCH:

sonolus/script/debug.py

@@ -7,7 +7,7 @@ from sonolus.backend.ops import Op
 from sonolus.backend.optimize.flow import cfg_to_mermaid
 from sonolus.backend.optimize.passes import CompilerPass, OptimizerConfig, run_passes
 from sonolus.backend.optimize.simplify import RenumberVars
-from sonolus.script.internal.context import GlobalContextState, ReadOnlyMemory, ctx, set_ctx
+from sonolus.script.internal.context import ModeContextState, ProjectContextState, ctx, set_ctx
 from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.native import native_function
 from sonolus.script.internal.simulation_context import SimulationContext
@@ -27,7 +27,7 @@ def error(message: str | None = None) -> Never:  # type: ignore
     if not isinstance(message, str):
         raise ValueError("Expected a string")
     if ctx():
-        debug_log(ctx().map_constant(message))
+        debug_log(ctx().map_debug_message(message))
         debug_pause()
         terminate()
     else:
@@ -68,6 +68,19 @@ def debug_pause():
     input("[DEBUG] Paused")
 
 
+@meta_fn
+def notify(message: str):
+    """Log a code that can be decoded by the dev server and pause the game if in debug mode."""
+    message = validate_value(message)._as_py_()  # type: ignore
+    if not isinstance(message, str):
+        raise ValueError("Expected a string")
+    if ctx():
+        debug_log(ctx().map_debug_message(message))
+        debug_pause()
+    else:
+        print(f"[NOTIFY] {message}")
+
+
 @meta_fn
 def assert_true(value: int | float | bool, message: str | None = None):
     if not ctx():
@@ -156,13 +169,13 @@ def visualize_cfg(
                 RenumberVars(),
             ]
 
-    global_state = GlobalContextState(
+    project_state = ProjectContextState()
+    mode_state = ModeContextState(
         mode,
         {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None,
-        ReadOnlyMemory(),
     )
 
-    cfg = callback_to_cfg(global_state, fn, callback, archetype=archetype)  # type: ignore
+    cfg = callback_to_cfg(project_state, mode_state, fn, callback, archetype=archetype)  # type: ignore
     cfg = run_passes(cfg, passes, OptimizerConfig(mode=mode))
     return cfg_to_mermaid(cfg)
 

sonolus/script/internal/context.py

@@ -39,19 +39,35 @@ _disabled_debug_config = DebugConfig(
 debug_var = ContextVar("debug_var", default=_disabled_debug_config)
 
 
-class GlobalContextState:
+class ProjectContextState:
+    rom: ReadOnlyMemory
+    const_mappings: dict[Any, int]
+    debug_str_mappings: dict[str, int]
+    lock: Lock
+
+    def __init__(
+        self,
+        rom: ReadOnlyMemory | None = None,
+        const_mappings: dict[Any, int] | None = None,
+        debug_str_mappings: dict[str, int] | None = None,
+    ):
+        self.rom = ReadOnlyMemory() if rom is None else rom
+        self.const_mappings = {} if const_mappings is None else const_mappings
+        self.debug_str_mappings = {} if debug_str_mappings is None else debug_str_mappings
+        self.lock = Lock()
+
+
+class ModeContextState:
     archetypes: dict[type, int]
     archetypes_by_name: dict[str, type]
     keys_by_archetype_id: Sequence[int]
     is_scored_by_archetype_id: Sequence[bool]
-    rom: ReadOnlyMemory
-    const_mappings: dict[Any, int]
     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):
+    def __init__(self, mode: Mode, archetypes: dict[type, int] | None = None):
         from sonolus.script.array import Array
 
         self.archetypes = archetypes or {}
@@ -65,8 +81,6 @@ class GlobalContextState:
             if archetypes
             else Array[bool, Literal[0]]()
         )
-        self.rom = ReadOnlyMemory() if rom is None else rom
-        self.const_mappings = {}
         self.environment_mappings = {}
         self.environment_offsets = {}
         self.mode = mode
@@ -76,16 +90,19 @@ class GlobalContextState:
 class CallbackContextState:
     callback: str
     used_names: dict[str, int]
+    debug_stack: list[str]
     no_eval: bool
 
     def __init__(self, callback: str, no_eval: bool = False):
         self.callback = callback
         self.used_names = {}
+        self.debug_stack = []
         self.no_eval = no_eval
 
 
 class Context:
-    global_state: GlobalContextState
+    project_state: ProjectContextState
+    mode_state: ModeContextState
     callback_state: CallbackContextState
     statements: list[IRStmt]
     test: IRExpr
@@ -96,13 +113,15 @@ class Context:
 
     def __init__(
         self,
-        global_state: GlobalContextState,
+        project_state: ProjectContextState,
+        mode_state: ModeContextState,
         callback_state: CallbackContextState,
         scope: Scope | None = None,
         live: bool = True,
         foldable_constants: dict[TempBlock, list[float | None]] | None = None,
     ):
-        self.global_state = global_state
+        self.project_state = project_state
+        self.mode_state = mode_state
         self.callback_state = callback_state
         self.statements = []
         self.test = IRConst(0)
@@ -114,11 +133,11 @@ class Context:
 
     @property
     def rom(self) -> ReadOnlyMemory:
-        return self.global_state.rom
+        return self.project_state.rom
 
     @property
     def blocks(self) -> type[Block]:
-        return self.global_state.mode.blocks
+        return self.mode_state.mode.blocks
 
     @property
     def callback(self) -> str:
@@ -182,7 +201,8 @@ class Context:
 
     def copy_with_scope(self, scope: Scope) -> Context:
         return Context(
-            global_state=self.global_state,
+            project_state=self.project_state,
+            mode_state=self.mode_state,
             callback_state=self.callback_state,
             scope=scope,
             live=self.live,
@@ -267,25 +287,33 @@ class Context:
                         )
 
     def map_constant(self, value: Any) -> int:
-        with self.global_state.lock:
-            const_mappings = self.global_state.const_mappings
+        with self.project_state.lock:
+            const_mappings = self.project_state.const_mappings
             if value not in const_mappings:
                 const_mappings[value] = len(const_mappings)
             return const_mappings[value]
 
+    def map_debug_message(self, message: str) -> int:
+        with self.project_state.lock:
+            message_with_trace = "\n".join([*self.callback_state.debug_stack, message])
+            debug_str_mappings = self.project_state.debug_str_mappings
+            if message_with_trace not in debug_str_mappings:
+                debug_str_mappings[message_with_trace] = len(debug_str_mappings) + 1
+            return debug_str_mappings[message_with_trace]
+
     def get_global_base(self, value: _GlobalInfo | _GlobalPlaceholder) -> BlockPlace:
-        with self.global_state.lock:
-            block = value.blocks.get(self.global_state.mode)
+        with self.mode_state.lock:
+            block = value.blocks.get(self.mode_state.mode)
             if block is None:
-                raise RuntimeError(f"Global {value} is not available in '{self.global_state.mode.name}' mode")
-            if value not in self.global_state.environment_mappings:
+                raise RuntimeError(f"Global {value} is not available in '{self.mode_state.mode.name}' mode")
+            if value not in self.mode_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
+                    offset = self.mode_state.environment_offsets.get(block, 0)
+                    self.mode_state.environment_mappings[value] = offset
+                    self.mode_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])
+                    self.mode_state.environment_mappings[value] = value.offset
+            return BlockPlace(block, self.mode_state.environment_mappings[value])
 
     @classmethod
     def meet(cls, contexts: list[Context]) -> Context:
@@ -303,10 +331,10 @@ class Context:
         return target
 
     def register_archetype(self, type_: type) -> int:
-        with self.global_state.lock:
-            if type_ not in self.global_state.archetypes:
-                self.global_state.archetypes[type_] = len(self.global_state.archetypes)
-            return self.global_state.archetypes[type_]
+        with self.mode_state.lock:
+            if type_ not in self.mode_state.archetypes:
+                self.mode_state.archetypes[type_] = len(self.mode_state.archetypes)
+            return self.mode_state.archetypes[type_]
 
 
 def ctx() -> Context | Any:  # Using Any to silence type checker warnings if it's None

sonolus/script/options.py

@@ -191,7 +191,7 @@ class _OptionField(SonolusDescriptor):
         if sim_ctx():
             return sim_ctx().get_or_put_value((instance, self), lambda: copy(self.info.default))
         if ctx():
-            match ctx().global_state.mode:
+            match ctx().mode_state.mode:
                 case Mode.PLAY:
                     block = ctx().blocks.LevelOption
                 case Mode.WATCH:
@@ -212,7 +212,7 @@ class _OptionField(SonolusDescriptor):
         if sim_ctx():
             return sim_ctx().set_or_put_value((instance, self), lambda: copy(self.info.default), value)
         if ctx() and debug_config().unchecked_writes:
-            match ctx().global_state.mode:
+            match ctx().mode_state.mode:
                 case Mode.PLAY:
                     block = ctx().blocks.LevelOption
                 case Mode.WATCH:

sonolus/script/project.py

@@ -8,7 +8,6 @@ from typing import ClassVar, TypedDict
 
 from sonolus.backend.optimize import optimize
 from sonolus.backend.optimize.passes import CompilerPass
-from sonolus.build.compile import CompileCache
 from sonolus.script.archetype import ArchetypeSchema
 from sonolus.script.engine import Engine
 from sonolus.script.level import ExternalLevelData, Level, LevelData
@@ -64,13 +63,11 @@ class Project:
             port: The port of the development server.
             config: The build configuration.
         """
-        from sonolus.build.cli import build_collection, run_server
+        from sonolus.build.cli import run_server
 
         if config is None:
             config = BuildConfig()
 
-        cache = CompileCache()
-        build_collection(self, Path(build_dir), config, cache=cache)
         run_server(
             Path(build_dir) / "site",
             port=port,
@@ -78,7 +75,7 @@ class Project:
             core_module_names=None,
             build_dir=Path(build_dir),
             config=config,
-            cache=cache,
+            project=self,
         )
 
     def build(self, build_dir: PathLike, config: BuildConfig | None = None):