sonolus.py 0.1.0__py3-none-any.whl

sonolus/build/engine.py

@@ -0,0 +1,149 @@
+import gzip
+import json
+import struct
+from collections.abc import Callable
+from dataclasses import dataclass
+from pathlib import Path
+
+from sonolus.backend.mode import Mode
+from sonolus.build.compile import compile_mode
+from sonolus.build.defaults import EMPTY_ENGINE_PREVIEW_DATA, 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.effect import Effects
+from sonolus.script.engine import EngineData
+from sonolus.script.internal.context import ReadOnlyMemory
+from sonolus.script.options import Options
+from sonolus.script.particle import Particles
+from sonolus.script.sprite import Skin
+from sonolus.script.ui import UiConfig
+
+type JsonValue = None | bool | int | float | str | list[JsonValue] | dict[str, JsonValue]
+
+
+@dataclass
+class PackagedEngine:
+    configuration: bytes
+    play_data: bytes
+    watch_data: bytes
+    preview_data: bytes
+    tutorial_data: bytes
+    rom: bytes
+
+    def write(self, path: Path):
+        path.mkdir(parents=True, exist_ok=True)
+        (path / "EngineConfiguration").write_bytes(self.configuration)
+        (path / "EnginePlayData").write_bytes(self.play_data)
+        (path / "EngineWatchData").write_bytes(self.watch_data)
+        (path / "EnginePreviewData").write_bytes(self.preview_data)
+        (path / "EngineTutorialData").write_bytes(self.tutorial_data)
+        (path / "EngineRom").write_bytes(self.rom)
+
+
+def package_engine(engine: EngineData):
+    rom = ReadOnlyMemory()
+    configuration = build_engine_configuration(engine.options, engine.ui)
+    play_data = build_play_mode(
+        archetypes=engine.play.archetypes,
+        skin=engine.play.skin,
+        effects=engine.play.effects,
+        particles=engine.play.particles,
+        buckets=engine.play.buckets,
+        rom=rom,
+    )
+    watch_data = build_watch_mode(
+        archetypes=engine.watch.archetypes,
+        skin=engine.watch.skin,
+        effects=engine.watch.effects,
+        particles=engine.watch.particles,
+        buckets=engine.watch.buckets,
+        rom=rom,
+        update_spawn=engine.watch.update_spawn,
+    )
+    return PackagedEngine(
+        configuration=package_output(configuration),
+        play_data=package_output(play_data),
+        watch_data=package_output(watch_data),
+        preview_data=package_output(EMPTY_ENGINE_PREVIEW_DATA),
+        tutorial_data=package_output(EMPTY_ENGINE_TUTORIAL_DATA),
+        rom=package_rom(rom),
+    )
+
+
+def build_engine_configuration(
+    options: Options,
+    ui: UiConfig,
+) -> JsonValue:
+    return {
+        "options": [option.to_dict() for option in options._options_],
+        "ui": ui.to_dict(),
+    }
+
+
+def build_play_mode(
+    archetypes: list[type[BaseArchetype]],
+    skin: Skin,
+    effects: Effects,
+    particles: Particles,
+    buckets: Buckets,
+    rom: ReadOnlyMemory,
+):
+    return {
+        **compile_mode(mode=Mode.Play, rom=rom, archetypes=archetypes, global_callbacks=None),
+        "skin": build_skin(skin),
+        "effect": build_effects(effects),
+        "particle": build_particles(particles),
+        "buckets": build_buckets(buckets),
+    }
+
+
+def build_watch_mode(
+    archetypes: list[type[BaseArchetype]],
+    skin: Skin,
+    effects: Effects,
+    particles: Particles,
+    buckets: Buckets,
+    rom: ReadOnlyMemory,
+    update_spawn: Callable[[], float],
+):
+    return {
+        **compile_mode(
+            mode=Mode.Watch, rom=rom, archetypes=archetypes, global_callbacks=[(update_spawn_callback, update_spawn)]
+        ),
+        "skin": build_skin(skin),
+        "effect": build_effects(effects),
+        "particle": build_particles(particles),
+        "buckets": build_buckets(buckets),
+    }
+
+
+def build_skin(skin: Skin) -> JsonValue:
+    return {"sprites": [{"name": name, "id": i} for i, name in enumerate(skin._sprites_)]}
+
+
+def build_effects(effects: Effects) -> JsonValue:
+    return {"clips": [{"name": name, "id": i} for i, name in enumerate(effects._effects_)]}
+
+
+def build_particles(particles: Particles) -> JsonValue:
+    return {"effects": [{"name": name, "id": i} for i, name in enumerate(particles._particles_)]}
+
+
+def build_buckets(buckets: Buckets) -> JsonValue:
+    return [bucket.to_dict() for bucket in buckets._buckets_]
+
+
+def package_rom(rom: ReadOnlyMemory) -> bytes:
+    values = rom.values or [0]
+    output = bytearray()
+
+    for value in values:
+        output.extend(struct.pack("<f", value))
+
+    return gzip.compress(bytes(output))
+
+
+def package_output(value: JsonValue) -> bytes:
+    json_data = json.dumps(value, separators=(",", ":")).encode("utf-8")
+    return gzip.compress(json_data)

sonolus/build/level.py

@@ -0,0 +1,23 @@
+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
+        ],
+    }

sonolus/build/node.py

@@ -0,0 +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

sonolus/build/project.py

@@ -0,0 +1,94 @@
+from pathlib import Path
+
+from sonolus.build.collection import Asset, Collection, Srl
+from sonolus.build.engine import package_engine
+from sonolus.build.level import package_level_data
+from sonolus.script.engine import Engine
+from sonolus.script.level import Level
+from sonolus.script.project import Project
+
+BLANK_PNG = (
+    b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR\x00\x00\x00\x01\x00\x00\x00\x01\x01\x00\x00\x00\x007n\xf9$"
+    b"\x00\x00\x00\nIDATx\x01c`\x00\x00\x00\x02\x00\x01su\x01\x18\x00\x00\x00\x00IEND\xaeB`\x82"
+)
+BLANK_AUDIO = (
+    b"RIFF$\x00\x00\x00WAVEfmt \x10\x00\x00\x00\x01\x00\x01\x00D\xac\x00\x00\x88X\x01\x00\x02"
+    b"\x00\x10\x00data\x00\x00\x00\x00"
+)
+
+
+def build_project_to_collection(project: Project):
+    collection = load_resources_files_to_collection(project.resources)
+    add_engine_to_collection(collection, project, project.engine)
+    for level in project.levels:
+        add_level_to_collection(collection, project, level)
+    collection.name = f"{project.engine.name}"
+    return collection
+
+
+def add_engine_to_collection(collection: Collection, project: Project, engine: Engine):
+    packaged_engine = package_engine(engine.data)
+    item = {
+        "name": engine.name,
+        "version": engine.version,
+        "title": engine.title,
+        "subtitle": engine.subtitle,
+        "author": engine.author,
+        "tags": [],
+        "skin": collection.get_item("skins", engine.skin) if engine.skin else collection.get_default_item("skins"),
+        "background": collection.get_item("backgrounds", engine.background)
+        if engine.background
+        else collection.get_default_item("backgrounds"),
+        "effect": collection.get_item("effects", engine.effect)
+        if engine.effect
+        else collection.get_default_item("effects"),
+        "particle": collection.get_item("particles", engine.particle)
+        if engine.particle
+        else collection.get_default_item("particles"),
+        "thumbnail": load_resource(collection, engine.thumbnail, project.resources, BLANK_PNG),
+        "playData": collection.add_asset(packaged_engine.play_data),
+        "watchData": collection.add_asset(packaged_engine.watch_data),
+        "previewData": collection.add_asset(packaged_engine.preview_data),
+        "tutorialData": collection.add_asset(packaged_engine.tutorial_data),
+        "rom": collection.add_asset(packaged_engine.rom),
+        "configuration": collection.add_asset(packaged_engine.configuration),
+    }
+    collection.add_item("engines", engine.name, item)
+
+
+def add_level_to_collection(collection: Collection, project: Project, level: Level):
+    packaged_level_data = package_level_data(level.data)
+    item = {
+        "name": level.name,
+        "version": level.version,
+        "rating": level.rating,
+        "title": level.title,
+        "artists": level.artists,
+        "author": level.author,
+        "tags": [],
+        "engine": collection.get_item("engines", project.engine.name),
+        "useSkin": {"useDefault": True},
+        "useBackground": {"useDefault": True},
+        "useEffect": {"useDefault": True},
+        "useParticle": {"useDefault": True},
+        "cover": load_resource(collection, level.cover, project.resources, BLANK_PNG),
+        "bgm": load_resource(collection, level.bgm, project.resources, BLANK_AUDIO),
+        "data": collection.add_asset(packaged_level_data),
+    }
+    collection.add_item("levels", level.name, item)
+
+
+def load_resource(collection: Collection, asset: Asset | None, base_path: Path, default: bytes) -> Srl:
+    if asset is None:
+        return collection.add_asset(default)
+    if isinstance(asset, str) and not asset.startswith(("http://", "https://")):
+        return collection.add_asset(base_path / asset)
+    return collection.add_asset(asset)
+
+
+def load_resources_files_to_collection(base_path: Path) -> Collection:
+    collection = Collection()
+    for path in base_path.rglob("*.scp"):
+        collection.load_from_scp(path)
+    collection.load_from_source(base_path)
+    return collection