sonolus.py 0.1.3__py3-none-any.whl → 0.1.5__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.ir import IRConst, IRInstr
+from sonolus.backend.mode import Mode
+from sonolus.backend.ops import Op
+from sonolus.backend.optimize.flow import BasicBlock
+from sonolus.backend.optimize.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.internal.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,15 +7,20 @@ from pathlib import Path
 
 from sonolus.backend.mode import Mode
 from sonolus.build.compile import compile_mode
-from sonolus.script.archetype import BaseArchetype
+from sonolus.script.archetype import _BaseArchetype
 from sonolus.script.bucket import Buckets
-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.callbacks import (
+    navigate_callback,
+    preprocess_callback,
+    update_callback,
+    update_spawn_callback,
+)
 from sonolus.script.internal.context import ReadOnlyMemory
 from sonolus.script.options import Options
 from sonolus.script.particle import Particles
@@ -101,7 +106,7 @@ def build_engine_configuration(
 
 
 def build_play_mode(
-    archetypes: list[type[BaseArchetype]],
+    archetypes: list[type[_BaseArchetype]],
     skin: Skin,
     effects: Effects,
     particles: Particles,
@@ -118,7 +123,7 @@ def build_play_mode(
 
 
 def build_watch_mode(
-    archetypes: list[type[BaseArchetype]],
+    archetypes: list[type[_BaseArchetype]],
     skin: Skin,
     effects: Effects,
     particles: Particles,
@@ -138,7 +143,7 @@ def build_watch_mode(
 
 
 def build_preview_mode(
-    archetypes: list[type[BaseArchetype]],
+    archetypes: list[type[_BaseArchetype]],
     skin: Skin,
     rom: ReadOnlyMemory,
 ):

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