sonolus.py 0.1.2__py3-none-any.whl → 0.1.4__py3-none-any.whl

sonolus/build/cli.py

@@ -7,6 +7,7 @@ import socket
 import socketserver
 import sys
 from pathlib import Path
+from time import perf_counter
 
 from sonolus.build.engine import package_engine
 from sonolus.build.level import package_level_data
@@ -163,8 +164,13 @@ def main():
     build_dir = Path(args.build_dir)
 
     if args.command == "build":
+        start_time = perf_counter()
         build_project(project, build_dir)
-        print(f"Project built successfully to '{build_dir.resolve()}'")
+        end_time = perf_counter()
+        print(f"Project built successfully to '{build_dir.resolve()}' in {end_time - start_time:.2f}s")
     elif args.command == "dev":
+        start_time = perf_counter()
         build_collection(project, build_dir)
+        end_time = perf_counter()
+        print(f"Build finished in {end_time - start_time:.2f}s")
         run_server(build_dir / "site", port=args.port)

sonolus/build/compile.py

@@ -1,90 +1,88 @@
-from collections.abc import Callable
-
-from sonolus.backend.finalize import cfg_to_engine_node
-from sonolus.backend.flow import BasicBlock
-from sonolus.backend.ir import IRConst, IRInstr
-from sonolus.backend.mode import Mode
-from sonolus.backend.ops import Op
-from sonolus.backend.optimize import optimize_and_allocate
-from sonolus.backend.visitor import compile_and_call
-from sonolus.build.node import OutputNodeGenerator
-from sonolus.script.archetype import BaseArchetype
-from sonolus.script.callbacks import CallbackInfo
-from sonolus.script.internal.context import (
-    CallbackContextState,
-    Context,
-    GlobalContextState,
-    ReadOnlyMemory,
-    context_to_cfg,
-    ctx,
-    using_ctx,
-)
-from sonolus.script.num import is_num
-
-
-def compile_mode(
-    mode: Mode,
-    rom: ReadOnlyMemory,
-    archetypes: list[type[BaseArchetype]] | None,
-    global_callbacks: list[tuple[CallbackInfo, Callable]] | None,
-) -> dict:
-    global_state = GlobalContextState(
-        mode, {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None, rom
-    )
-    nodes = OutputNodeGenerator()
-    results = {}
-    if archetypes is not None:
-        archetype_entries = []
-        for archetype in archetypes:
-            archetype_data = {
-                "name": archetype.name,
-                "hasInput": archetype.is_scored,
-            }
-            archetype_data["imports"] = [
-                {"name": name, "index": index} for name, index in archetype._imported_keys_.items()
-            ]
-            if mode == Mode.PLAY:
-                archetype_data["exports"] = [
-                    {"name": name, "index": index} for name, index in archetype._exported_keys_.items()
-                ]
-            for cb_name, cb_info in archetype._supported_callbacks_.items():
-                cb = getattr(archetype, cb_name)
-                if cb in archetype._default_callbacks_:
-                    continue
-                cb_order = getattr(cb, "_callback_order_", 0)
-                if not cb_info.supports_order and cb_order != 0:
-                    raise ValueError(f"Callback '{cb_name}' does not support a non-zero order")
-                cfg = callback_to_cfg(global_state, cb, cb_info.name, archetype)
-                cfg = optimize_and_allocate(cfg)
-                node = cfg_to_engine_node(cfg)
-                node_index = nodes.add(node)
-                archetype_data[cb_info.name] = {
-                    "index": node_index,
-                    "order": cb_order,
-                }
-            archetype_entries.append(archetype_data)
-        results["archetypes"] = archetype_entries
-    if global_callbacks is not None:
-        for cb_info, cb in global_callbacks:
-            cfg = callback_to_cfg(global_state, cb, cb_info.name)
-            cfg = optimize_and_allocate(cfg)
-            node = cfg_to_engine_node(cfg)
-            node_index = nodes.add(node)
-            results[cb_info.name] = node_index
-    results["nodes"] = nodes.get()
-    return results
-
-
-def callback_to_cfg(
-    global_state: GlobalContextState, callback: Callable, name: str, archetype: type[BaseArchetype] | None = None
-) -> BasicBlock:
-    callback_state = CallbackContextState(name)
-    context = Context(global_state, callback_state)
-    with using_ctx(context):
-        if archetype is not None:
-            result = compile_and_call(callback, archetype._for_compilation())
-        else:
-            result = compile_and_call(callback)
-        if is_num(result):
-            ctx().add_statements(IRInstr(Op.Break, [IRConst(1), result.ir()]))
-    return context_to_cfg(context)
+from collections.abc import Callable
+
+from sonolus.backend.finalize import cfg_to_engine_node
+from sonolus.backend.flow import BasicBlock
+from sonolus.backend.ir import IRConst, IRInstr
+from sonolus.backend.mode import Mode
+from sonolus.backend.ops import Op
+from sonolus.backend.optimize import optimize_and_allocate
+from sonolus.backend.visitor import compile_and_call
+from sonolus.build.node import OutputNodeGenerator
+from sonolus.script.archetype import BaseArchetype
+from sonolus.script.callbacks import CallbackInfo
+from sonolus.script.internal.context import (
+    CallbackContextState,
+    Context,
+    GlobalContextState,
+    ReadOnlyMemory,
+    context_to_cfg,
+    ctx,
+    using_ctx,
+)
+from sonolus.script.num import is_num
+
+
+def compile_mode(
+    mode: Mode,
+    rom: ReadOnlyMemory,
+    archetypes: list[type[BaseArchetype]] | None,
+    global_callbacks: list[tuple[CallbackInfo, Callable]] | None,
+) -> dict:
+    global_state = GlobalContextState(
+        mode, {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None, rom
+    )
+    nodes = OutputNodeGenerator()
+    results = {}
+    if archetypes is not None:
+        archetype_entries = []
+        for archetype in archetypes:
+            archetype_data = {
+                "name": archetype.name,
+                "hasInput": archetype.is_scored,
+                "imports": [{"name": name, "index": index} for name, index in archetype._imported_keys_.items()],
+            }
+            if mode == Mode.PLAY:
+                archetype_data["exports"] = [
+                    {"name": name, "index": index} for name, index in archetype._exported_keys_.items()
+                ]
+            for cb_name, cb_info in archetype._supported_callbacks_.items():
+                cb = getattr(archetype, cb_name)
+                if cb in archetype._default_callbacks_:
+                    continue
+                cb_order = getattr(cb, "_callback_order_", 0)
+                if not cb_info.supports_order and cb_order != 0:
+                    raise ValueError(f"Callback '{cb_name}' does not support a non-zero order")
+                cfg = callback_to_cfg(global_state, cb, cb_info.name, archetype)
+                cfg = optimize_and_allocate(cfg)
+                node = cfg_to_engine_node(cfg)
+                node_index = nodes.add(node)
+                archetype_data[cb_info.name] = {
+                    "index": node_index,
+                    "order": cb_order,
+                }
+            archetype_entries.append(archetype_data)
+        results["archetypes"] = archetype_entries
+    if global_callbacks is not None:
+        for cb_info, cb in global_callbacks:
+            cfg = callback_to_cfg(global_state, cb, cb_info.name)
+            cfg = optimize_and_allocate(cfg)
+            node = cfg_to_engine_node(cfg)
+            node_index = nodes.add(node)
+            results[cb_info.name] = node_index
+    results["nodes"] = nodes.get()
+    return results
+
+
+def callback_to_cfg(
+    global_state: GlobalContextState, callback: Callable, name: str, archetype: type[BaseArchetype] | None = None
+) -> BasicBlock:
+    callback_state = CallbackContextState(name)
+    context = Context(global_state, callback_state)
+    with using_ctx(context):
+        if archetype is not None:
+            result = compile_and_call(callback, archetype._for_compilation())
+        else:
+            result = compile_and_call(callback)
+        if is_num(result):
+            ctx().add_statements(IRInstr(Op.Break, [IRConst(1), result.ir()]))
+    return context_to_cfg(context)

sonolus/build/engine.py

@@ -7,12 +7,15 @@ from pathlib import Path
 
 from sonolus.backend.mode import Mode
 from sonolus.build.compile import compile_mode
-from sonolus.build.defaults import EMPTY_ENGINE_TUTORIAL_DATA
 from sonolus.script.archetype import BaseArchetype
 from sonolus.script.bucket import Buckets
-from sonolus.script.callbacks import update_spawn_callback
+from sonolus.script.callbacks import navigate_callback, preprocess_callback, update_callback, update_spawn_callback
 from sonolus.script.effect import Effects
 from sonolus.script.engine import EngineData
+from sonolus.script.instruction import (
+    TutorialInstructionIcons,
+    TutorialInstructions,
+)
 from sonolus.script.internal.context import ReadOnlyMemory
 from sonolus.script.options import Options
 from sonolus.script.particle import Particles
@@ -61,17 +64,28 @@ def package_engine(engine: EngineData):
         rom=rom,
         update_spawn=engine.watch.update_spawn,
     )
-    preview_mode = build_preview_mode(
+    preview_data = build_preview_mode(
         archetypes=engine.preview.archetypes,
         skin=engine.preview.skin,
         rom=rom,
     )
+    tutorial_data = build_tutorial_mode(
+        skin=engine.tutorial.skin,
+        effects=engine.tutorial.effects,
+        particles=engine.tutorial.particles,
+        instructions=engine.tutorial.instructions,
+        instruction_icons=engine.tutorial.instruction_icons,
+        preprocess=engine.tutorial.preprocess,
+        navigate=engine.tutorial.navigate,
+        update=engine.tutorial.update,
+        rom=rom,
+    )
     return PackagedEngine(
         configuration=package_output(configuration),
         play_data=package_output(play_data),
         watch_data=package_output(watch_data),
-        preview_data=package_output(preview_mode),
-        tutorial_data=package_output(EMPTY_ENGINE_TUTORIAL_DATA),
+        preview_data=package_output(preview_data),
+        tutorial_data=package_output(tutorial_data),
         rom=package_rom(rom),
     )
 
@@ -134,6 +148,35 @@ def build_preview_mode(
     }
 
 
+def build_tutorial_mode(
+    skin: Skin,
+    effects: Effects,
+    particles: Particles,
+    instructions: TutorialInstructions,
+    instruction_icons: TutorialInstructionIcons,
+    preprocess: Callable[[], None],
+    navigate: Callable[[int], None],
+    update: Callable[[], None],
+    rom: ReadOnlyMemory,
+):
+    return {
+        **compile_mode(
+            mode=Mode.TUTORIAL,
+            rom=rom,
+            archetypes=[],
+            global_callbacks=[
+                (preprocess_callback, preprocess),
+                (navigate_callback, navigate),
+                (update_callback, update),
+            ],
+        ),
+        "skin": build_skin(skin),
+        "effect": build_effects(effects),
+        "particle": build_particles(particles),
+        "instruction": build_instructions(instructions, instruction_icons),
+    }
+
+
 def build_skin(skin: Skin) -> JsonValue:
     return {"sprites": [{"name": name, "id": i} for i, name in enumerate(skin._sprites_)]}
 
@@ -150,6 +193,13 @@ def build_buckets(buckets: Buckets) -> JsonValue:
     return [bucket.to_dict() for bucket in buckets._buckets_]
 
 
+def build_instructions(instructions: TutorialInstructions, instruction_icons: TutorialInstructionIcons) -> JsonValue:
+    return {
+        "texts": [{"name": name, "id": i} for i, name in enumerate(instructions._instructions_)],
+        "icons": [{"name": name, "id": i} for i, name in enumerate(instruction_icons._instruction_icons_)],
+    }
+
+
 def package_rom(rom: ReadOnlyMemory) -> bytes:
     values = rom.values or [0]
     output = bytearray()

sonolus/build/level.py

@@ -1,23 +1,24 @@
-from sonolus.build.engine import package_output
-from sonolus.script.level import LevelData
-
-
-def package_level_data(
-    level_data: LevelData,
-):
-    return package_output(build_level_data(level_data))
-
-
-def build_level_data(
-    level_data: LevelData,
-):
-    return {
-        "bgmOffset": level_data.bgm_offset,
-        "entities": [
-            {
-                "archetype": entity.name,
-                "data": entity._level_data_entries(),
-            }
-            for entity in level_data.entities
-        ],
-    }
+from sonolus.build.engine import package_output
+from sonolus.script.level import LevelData
+
+
+def package_level_data(
+    level_data: LevelData,
+):
+    return package_output(build_level_data(level_data))
+
+
+def build_level_data(
+    level_data: LevelData,
+):
+    level_refs = {entity: i for i, entity in enumerate(level_data.entities)}
+    return {
+        "bgmOffset": level_data.bgm_offset,
+        "entities": [
+            {
+                "archetype": entity.name,
+                "data": entity._level_data_entries(level_refs),
+            }
+            for entity in level_data.entities
+        ],
+    }

sonolus/build/node.py

@@ -1,43 +1,43 @@
-from typing import TypedDict
-
-from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
-
-
-class ValueOutputNode(TypedDict):
-    value: float
-
-
-class FunctionOutputNode(TypedDict):
-    func: str
-    args: list[int]
-
-
-class OutputNodeGenerator:
-    nodes: list[ValueOutputNode | FunctionOutputNode]
-    indexes: dict[EngineNode, int]
-
-    def __init__(self):
-        self.nodes = []
-        self.indexes = {}
-
-    def add(self, node: EngineNode):
-        if node in self.indexes:
-            return self.indexes[node]
-
-        match node:
-            case ConstantNode(value):
-                index = len(self.nodes)
-                self.nodes.append({"value": value})
-                self.indexes[node] = index
-                return index
-            case FunctionNode(func, args):
-                arg_indexes = [self.add(arg) for arg in args]
-                index = len(self.nodes)
-                self.nodes.append({"func": func.value, "args": arg_indexes})
-                self.indexes[node] = index
-                return index
-            case _:
-                raise ValueError("Invalid node")
-
-    def get(self):
-        return self.nodes
+from typing import TypedDict
+
+from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
+
+
+class ValueOutputNode(TypedDict):
+    value: float
+
+
+class FunctionOutputNode(TypedDict):
+    func: str
+    args: list[int]
+
+
+class OutputNodeGenerator:
+    nodes: list[ValueOutputNode | FunctionOutputNode]
+    indexes: dict[EngineNode, int]
+
+    def __init__(self):
+        self.nodes = []
+        self.indexes = {}
+
+    def add(self, node: EngineNode):
+        if node in self.indexes:
+            return self.indexes[node]
+
+        match node:
+            case ConstantNode(value):
+                index = len(self.nodes)
+                self.nodes.append({"value": value})
+                self.indexes[node] = index
+                return index
+            case FunctionNode(func, args):
+                arg_indexes = [self.add(arg) for arg in args]
+                index = len(self.nodes)
+                self.nodes.append({"func": func.value, "args": arg_indexes})
+                self.indexes[node] = index
+                return index
+            case _:
+                raise ValueError("Invalid node")
+
+    def get(self):
+        return self.nodes

sonolus/script/archetype.py

@@ -10,6 +10,7 @@ from typing import Annotated, Any, ClassVar, Self, get_origin
 from sonolus.backend.ir import IRConst, IRInstr
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
+from sonolus.backend.place import BlockPlace
 from sonolus.script.bucket import Bucket, Judgment
 from sonolus.script.callbacks import PLAY_CALLBACKS, PREVIEW_CALLBACKS, WATCH_ARCHETYPE_CALLBACKS, CallbackInfo
 from sonolus.script.internal.context import ctx
@@ -80,7 +81,7 @@ class ArchetypeField(SonolusDescriptor):
                     case ArchetypeReferenceData(index=index):
                         result = deref(
                             ctx().blocks.EntitySharedMemoryArray,
-                            self.offset + index * ENTITY_SHARED_MEMORY_SIZE,
+                            Num._accept_(self.offset) + index * ENTITY_SHARED_MEMORY_SIZE,
                             self.type,
                         )
                     case ArchetypeLevelData():
@@ -135,7 +136,7 @@ class ArchetypeField(SonolusDescriptor):
                     case ArchetypeReferenceData(index=index):
                         target = deref(
                             ctx().blocks.EntitySharedMemoryArray,
-                            self.offset + index * ENTITY_SHARED_MEMORY_SIZE,
+                            Num._accept_(self.offset) + index * ENTITY_SHARED_MEMORY_SIZE,
                             self.type,
                         )
                     case ArchetypeLevelData():
@@ -257,7 +258,7 @@ class BaseArchetype:
     @meta_fn
     def at(cls, index: Num) -> Self:
         result = cls._new()
-        result._data_ = ArchetypeReferenceData(index=index)
+        result._data_ = ArchetypeReferenceData(index=Num._accept_(index))
         return result
 
     @classmethod
@@ -283,13 +284,13 @@ class BaseArchetype:
             data.extend(field.type._accept_(bound.arguments[field.name] or zeros(field.type))._to_list_())
         native_call(Op.Spawn, archetype_id, *(Num(x) for x in data))
 
-    def _level_data_entries(self):
+    def _level_data_entries(self, level_refs: dict[Any, int] | None = None):
         if not isinstance(self._data_, ArchetypeLevelData):
             raise RuntimeError("Entity is not level data")
         entries = []
         for name, value in self._data_.values.items():
             field_info = self._imported_fields_.get(name)
-            for k, v in value._to_flat_dict_(field_info.data_name).items():
+            for k, v in value._to_flat_dict_(field_info.data_name, level_refs).items():
                 entries.append({"name": k, "value": v})
         return entries
 
@@ -484,6 +485,13 @@ class PlayArchetype(BaseArchetype):
             case _:
                 raise RuntimeError("Result is only accessible from the entity itself")
 
+    def ref(self):
+        if not isinstance(self._data_, ArchetypeLevelData):
+            raise RuntimeError("Entity is not level data")
+        result = EntityRef[type(self)](index=-1)
+        result._ref_ = self
+        return result
+
 
 class WatchArchetype(BaseArchetype):
     _supported_callbacks_ = WATCH_ARCHETYPE_CALLBACKS
@@ -674,7 +682,16 @@ class EntityRef[A: BaseArchetype](Record):
         return cls._get_type_arg_(A)
 
     def get(self) -> A:
-        return self.archetype().at(Num(self.index))
+        return self.archetype().at(self.index)
+
+    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
+        ref = getattr(self, "_ref_", None)
+        if ref is None:
+            return [self.index]
+        else:
+            if ref not in level_refs:
+                raise KeyError("Reference to entity not in level data")
+            return [level_refs[ref]]
 
 
 class StandardArchetypeName(StrEnum):

sonolus/script/array.py

@@ -97,10 +97,10 @@ class Array[T, Size](GenericValue, ArrayLike[T]):
         iterator = iter(values)
         return cls(*(cls.element_type()._from_list_(iterator) for _ in range(cls.size())))
 
-    def _to_list_(self) -> list[float | BlockPlace]:
+    def _to_list_(self, level_refs: dict[Any, int] | None = None) -> list[float | BlockPlace]:
         match self._value:
             case list():
-                return [entry for value in self._value for entry in value._to_list_()]
+                return [entry for value in self._value for entry in value._to_list_(level_refs)]
             case BlockPlace():
                 return [
                     entry