sonolus.py 0.1.1__tar.gz → 0.1.2__tar.gz

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sonolus.py
-Version: 0.1.1
+Version: 0.1.2
 Summary: Sonolus engine development in Python
 License-File: LICENSE
 Requires-Python: >=3.13

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.1.1"
+version = "0.1.2"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.13"

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/backend/mode.py

@@ -7,10 +7,10 @@ from sonolus.backend.blocks import Block, PlayBlock, PreviewBlock, TutorialBlock
 class Mode(Enum):
     blocks: type[Block]
 
-    Play = (PlayBlock,)
-    Watch = (WatchBlock,)
-    Preview = (PreviewBlock,)
-    Tutorial = (TutorialBlock,)
+    PLAY = (PlayBlock,)
+    WATCH = (WatchBlock,)
+    PREVIEW = (PreviewBlock,)
+    TUTORIAL = (TutorialBlock,)
 
     def __init__(self, blocks: type[Block]):
         self.blocks = blocks

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/backend/visitor.py

@@ -17,7 +17,7 @@ from sonolus.script.internal.error import CompilationError
 from sonolus.script.internal.impl import try_validate_value, validate_value
 from sonolus.script.internal.value import Value
 from sonolus.script.iterator import SonolusIterator
-from sonolus.script.num import Num
+from sonolus.script.num import Num, is_num
 
 _compiler_internal_ = True
 
@@ -833,7 +833,7 @@ class Visitor(ast.NodeVisitor):
 
     def ensure_boolean_num(self, value) -> Num:
         # This just checks the type for now, although we could support custom __bool__ implementations in the future
-        if not isinstance(value, Num):
+        if not is_num(value):
             raise TypeError(f"Invalid type where a bool (Num) was expected: {type(value).__name__}")
         return value
 

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/build/compile.py

@@ -19,7 +19,7 @@ from sonolus.script.internal.context import (
     ctx,
     using_ctx,
 )
-from sonolus.script.num import Num
+from sonolus.script.num import is_num
 
 
 def compile_mode(
@@ -43,7 +43,7 @@ def compile_mode(
             archetype_data["imports"] = [
                 {"name": name, "index": index} for name, index in archetype._imported_keys_.items()
             ]
-            if mode == Mode.Play:
+            if mode == Mode.PLAY:
                 archetype_data["exports"] = [
                     {"name": name, "index": index} for name, index in archetype._exported_keys_.items()
                 ]
@@ -85,6 +85,6 @@ def callback_to_cfg(
             result = compile_and_call(callback, archetype._for_compilation())
         else:
             result = compile_and_call(callback)
-        if isinstance(result, Num):
+        if is_num(result):
             ctx().add_statements(IRInstr(Op.Break, [IRConst(1), result.ir()]))
     return context_to_cfg(context)

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/build/engine.py

@@ -7,7 +7,7 @@ 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.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
@@ -61,11 +61,16 @@ def package_engine(engine: EngineData):
         rom=rom,
         update_spawn=engine.watch.update_spawn,
     )
+    preview_mode = build_preview_mode(
+        archetypes=engine.preview.archetypes,
+        skin=engine.preview.skin,
+        rom=rom,
+    )
     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),
+        preview_data=package_output(preview_mode),
         tutorial_data=package_output(EMPTY_ENGINE_TUTORIAL_DATA),
         rom=package_rom(rom),
     )
@@ -90,7 +95,7 @@ def build_play_mode(
     rom: ReadOnlyMemory,
 ):
     return {
-        **compile_mode(mode=Mode.Play, rom=rom, archetypes=archetypes, global_callbacks=None),
+        **compile_mode(mode=Mode.PLAY, rom=rom, archetypes=archetypes, global_callbacks=None),
         "skin": build_skin(skin),
         "effect": build_effects(effects),
         "particle": build_particles(particles),
@@ -109,7 +114,7 @@ def build_watch_mode(
 ):
     return {
         **compile_mode(
-            mode=Mode.Watch, rom=rom, archetypes=archetypes, global_callbacks=[(update_spawn_callback, update_spawn)]
+            mode=Mode.WATCH, rom=rom, archetypes=archetypes, global_callbacks=[(update_spawn_callback, update_spawn)]
         ),
         "skin": build_skin(skin),
         "effect": build_effects(effects),
@@ -118,6 +123,17 @@ def build_watch_mode(
     }
 
 
+def build_preview_mode(
+    archetypes: list[type[BaseArchetype]],
+    skin: Skin,
+    rom: ReadOnlyMemory,
+):
+    return {
+        **compile_mode(mode=Mode.PREVIEW, rom=rom, archetypes=archetypes, global_callbacks=None),
+        "skin": build_skin(skin),
+    }
+
+
 def build_skin(skin: Skin) -> JsonValue:
     return {"sprites": [{"name": name, "id": i} for i, name in enumerate(skin._sprites_)]}
 

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/script/archetype.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 import inspect
 from collections.abc import Callable
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, StrEnum
 from types import FunctionType
 from typing import Annotated, Any, ClassVar, Self, get_origin
 
@@ -11,7 +11,7 @@ from sonolus.backend.ir import IRConst, IRInstr
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
 from sonolus.script.bucket import Bucket, Judgment
-from sonolus.script.callbacks import PLAY_CALLBACKS, WATCH_ARCHETYPE_CALLBACKS, CallbackInfo
+from sonolus.script.callbacks import PLAY_CALLBACKS, PREVIEW_CALLBACKS, WATCH_ARCHETYPE_CALLBACKS, CallbackInfo
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.descriptor import SonolusDescriptor
 from sonolus.script.internal.generic import validate_concrete_type
@@ -174,11 +174,11 @@ _annotation_defaults: dict[Callable, ArchetypeFieldInfo] = {
 
 
 class StandardImport:
-    Beat = Annotated[float, imported(name="#BEAT")]
-    Bpm = Annotated[float, imported(name="#BPM")]
-    Timescale = Annotated[float, imported(name="#TIMESCALE")]
-    Judgment = Annotated[int, imported(name="#JUDGMENT")]
-    Accuracy = Annotated[float, imported(name="#ACCURACY")]
+    BEAT = Annotated[float, imported(name="#BEAT")]
+    BPM = Annotated[float, imported(name="#BPM")]
+    TIMESCALE = Annotated[float, imported(name="#TIMESCALE")]
+    JUDGMENT = Annotated[int, imported(name="#JUDGMENT")]
+    ACCURACY = Annotated[float, imported(name="#ACCURACY")]
 
 
 def callback[T: Callable](order: int) -> Callable[[T], T]:
@@ -559,16 +559,42 @@ class WatchArchetype(BaseArchetype):
         self.result.target_time = value
 
 
+class PreviewArchetype(BaseArchetype):
+    _supported_callbacks_ = PREVIEW_CALLBACKS
+
+    def preprocess(self):
+        pass
+
+    def render(self):
+        pass
+
+    @property
+    def _info(self) -> PreviewEntityInfo:
+        if not ctx():
+            raise RuntimeError("Calling info is only allowed within a callback")
+        match self._data_:
+            case ArchetypeSelfData():
+                return deref(ctx().blocks.EntityInfo, 0, PreviewEntityInfo)
+            case ArchetypeReferenceData(index=index):
+                return deref(ctx().blocks.EntityInfoArray, index * PreviewEntityInfo._size_(), PreviewEntityInfo)
+            case _:
+                raise RuntimeError("Info is only accessible from the entity itself")
+
+    @property
+    def index(self) -> int:
+        return self._info.index
+
+
 @meta_fn
 def entity_info_at(index: Num) -> PlayEntityInfo | WatchEntityInfo | PreviewEntityInfo:
     if not ctx():
         raise RuntimeError("Calling entity_info_at is only allowed within a callback")
     match ctx().global_state.mode:
-        case Mode.Play:
+        case Mode.PLAY:
             return deref(ctx().blocks.EntityInfoArray, index * PlayEntityInfo._size_(), PlayEntityInfo)
-        case Mode.Watch:
+        case Mode.WATCH:
             return deref(ctx().blocks.EntityInfoArray, index * WatchEntityInfo._size_(), WatchEntityInfo)
-        case Mode.Preview:
+        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}'")
@@ -581,7 +607,7 @@ def archetype_life_of(archetype: type[BaseArchetype] | BaseArchetype) -> Archety
     if not ctx():
         raise RuntimeError("Calling archetype_life_of is only allowed within a callback")
     match ctx().global_state.mode:
-        case Mode.Play | Mode.Watch:
+        case Mode.PLAY | Mode.WATCH:
             return deref(ctx().blocks.ArchetypeLife, archetype.id() * ArchetypeLife._size_(), ArchetypeLife)
         case _:
             raise RuntimeError(f"Archetype life is not available in mode '{ctx().global_state.mode}'")
@@ -649,3 +675,8 @@ class EntityRef[A: BaseArchetype](Record):
 
     def get(self) -> A:
         return self.archetype().at(Num(self.index))
+
+
+class StandardArchetypeName(StrEnum):
+    BPM_CHANGE = "#BPM_CHANGE"
+    TIMESCALE_CHANGE = "#TIMESCALE_CHANGE"

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/script/bucket.py

@@ -88,9 +88,9 @@ class Bucket(Record):
         if not ctx():
             raise RuntimeError("Bucket window access outside of compilation")
         match ctx().global_state.mode:
-            case Mode.Play:
+            case Mode.PLAY:
                 return deref(ctx().blocks.LevelBucket, self.id * JudgmentWindow._size_(), JudgmentWindow)
-            case Mode.Watch:
+            case Mode.WATCH:
                 return deref(ctx().blocks.LevelBucket, self.id * JudgmentWindow._size_(), JudgmentWindow)
             case _:
                 raise RuntimeError("Invalid mode for bucket window access")

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/script/callbacks.py

@@ -75,6 +75,12 @@ update_spawn_callback = CallbackInfo(
     supports_order=False,
     returns_value=True,
 )
+render_callback = CallbackInfo(
+    name="render",
+    py_name="render",
+    supports_order=False,
+    returns_value=False,
+)
 
 
 def _by_name(*callbacks: CallbackInfo) -> dict[str, CallbackInfo]:
@@ -103,3 +109,7 @@ WATCH_ARCHETYPE_CALLBACKS = _by_name(
 WATCH_GLOBAL_CALLBACKS = _by_name(
     update_spawn_callback,
 )
+PREVIEW_CALLBACKS = _by_name(
+    preprocess_callback,
+    render_callback,
+)

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/script/comptime.py

@@ -3,6 +3,7 @@ from typing import TYPE_CHECKING, Any, Self, TypeVar, final
 
 from sonolus.backend.place import BlockPlace
 from sonolus.script.internal.generic import GenericValue
+from sonolus.script.internal.impl import meta_fn, validate_value
 
 
 @final
@@ -92,6 +93,19 @@ class _Comptime[T, V](GenericValue):
     def _copy_(self) -> Self:
         return self
 
+    @meta_fn
+    def __eq__(self, other):
+        other = validate_value(other)
+        match self.value():
+            case str():
+                return other._is_py_() and other._as_py_() == self.value()
+            case _:
+                raise TypeError("Unsupported comparison with comptime value")
+
+    @meta_fn
+    def __hash__(self):
+        return hash(self.value())
+
     @classmethod
     def _alloc_(cls) -> Self:
         return cls._instance

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/script/debug.py

@@ -65,6 +65,6 @@ def terminate():
 def visualize_cfg(fn: Callable[[], Any]) -> str:
     from sonolus.build.compile import callback_to_cfg
 
-    cfg = callback_to_cfg(GlobalContextState(Mode.Play), fn, "")
+    cfg = callback_to_cfg(GlobalContextState(Mode.PLAY), fn, "")
     cfg = CoalesceFlow().run(cfg)
     return cfg_to_mermaid(cfg)

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/script/effect.py

@@ -113,17 +113,17 @@ def effects[T](cls: type[T]) -> T | Effects:
 
 
 class StandardEffect:
-    Miss = Annotated[Effect, effect("#MISS")]
-    Perfect = Annotated[Effect, effect("#PERFECT")]
-    Great = Annotated[Effect, effect("#GREAT")]
-    Good = Annotated[Effect, effect("#GOOD")]
-    Hold = Annotated[Effect, effect("#HOLD")]
-    MissAlternative = Annotated[Effect, effect("#MISS_ALTERNATIVE")]
-    PerfectAlternative = Annotated[Effect, effect("#PERFECT_ALTERNATIVE")]
-    GreatAlternative = Annotated[Effect, effect("#GREAT_ALTERNATIVE")]
-    GoodAlternative = Annotated[Effect, effect("#GOOD_ALTERNATIVE")]
-    HoldAlternative = Annotated[Effect, effect("#HOLD_ALTERNATIVE")]
-    Stage = Annotated[Effect, effect("#STAGE")]
+    MISS = Annotated[Effect, effect("#MISS")]
+    PERFECT = Annotated[Effect, effect("#PERFECT")]
+    GREAT = Annotated[Effect, effect("#GREAT")]
+    GOOD = Annotated[Effect, effect("#GOOD")]
+    HOLD = Annotated[Effect, effect("#HOLD")]
+    MISS_ALTERNATIVE = Annotated[Effect, effect("#MISS_ALTERNATIVE")]
+    PERFECT_ALTERNATIVE = Annotated[Effect, effect("#PERFECT_ALTERNATIVE")]
+    GREAT_ALTERNATIVE = Annotated[Effect, effect("#GREAT_ALTERNATIVE")]
+    GOOD_ALTERNATIVE = Annotated[Effect, effect("#GOOD_ALTERNATIVE")]
+    HOLD_ALTERNATIVE = Annotated[Effect, effect("#HOLD_ALTERNATIVE")]
+    STAGE = Annotated[Effect, effect("#STAGE")]
 
 
 @effects

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/script/engine.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from collections.abc import Callable
 
 from sonolus.build.collection import Asset
-from sonolus.script.archetype import BaseArchetype
+from sonolus.script.archetype import BaseArchetype, PlayArchetype, PreviewArchetype, WatchArchetype
 from sonolus.script.bucket import Buckets, EmptyBuckets
 from sonolus.script.effect import Effects, EmptyEffects
 from sonolus.script.options import EmptyOptions, Options
@@ -61,6 +61,10 @@ class PlayMode:
         self.particles = particles
         self.buckets = buckets
 
+        for archetype in self.archetypes:
+            if not issubclass(archetype, PlayArchetype):
+                raise ValueError(f"archetype {archetype} is not a PlayArchetype")
+
 
 class WatchMode:
     def __init__(
@@ -80,13 +84,27 @@ class WatchMode:
         self.buckets = buckets
         self.update_spawn = update_spawn
 
+        for archetype in self.archetypes:
+            if not issubclass(archetype, WatchArchetype):
+                raise ValueError(f"archetype {archetype} is not a PlayArchetype")
 
-class EngineData:
-    ui: UiConfig
-    options: Options
-    play: PlayMode
-    watch: WatchMode
 
+class PreviewMode:
+    def __init__(
+        self,
+        *,
+        archetypes: list[type[BaseArchetype]] | None = None,
+        skin: Skin = EmptySkin,
+    ) -> None:
+        self.archetypes = archetypes or []
+        self.skin = skin
+
+        for archetype in self.archetypes:
+            if not issubclass(archetype, PreviewArchetype):
+                raise ValueError(f"archetype {archetype} is not a BaseArchetype")
+
+
+class EngineData:
     def __init__(
         self,
         *,
@@ -94,8 +112,10 @@ class EngineData:
         options: Options = EmptyOptions,
         play: PlayMode | None = None,
         watch: WatchMode | None = None,
+        preview: PreviewMode | None = None,
     ) -> None:
         self.ui = ui or UiConfig()
         self.options = options
         self.play = play or PlayMode()
         self.watch = watch or WatchMode(update_spawn=default_callback)
+        self.preview = preview or PreviewMode()

{sonolus_py-0.1.1 → sonolus_py-0.1.2}/sonolus/script/globals.py

@@ -86,42 +86,47 @@ def create_global(cls: type, blocks: dict[Mode, Block], offset: int | None):
 
 @dataclass_transform()
 def _play_runtime_environment[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Play: PlayBlock.RuntimeEnvironment}, 0)
+    return create_global(cls, {Mode.PLAY: PlayBlock.RuntimeEnvironment}, 0)
 
 
 @dataclass_transform()
 def _watch_runtime_environment[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Watch: WatchBlock.RuntimeEnvironment}, 0)
+    return create_global(cls, {Mode.WATCH: WatchBlock.RuntimeEnvironment}, 0)
 
 
 @dataclass_transform()
 def _tutorial_runtime_environment[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Tutorial: TutorialBlock.RuntimeEnvironment}, 0)
+    return create_global(cls, {Mode.TUTORIAL: TutorialBlock.RuntimeEnvironment}, 0)
 
 
 @dataclass_transform()
 def _preview_runtime_environment[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Preview: PreviewBlock.RuntimeEnvironment}, 0)
+    return create_global(cls, {Mode.PREVIEW: PreviewBlock.RuntimeEnvironment}, 0)
 
 
 @dataclass_transform()
 def _play_runtime_update[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Play: PlayBlock.RuntimeUpdate}, 0)
+    return create_global(cls, {Mode.PLAY: PlayBlock.RuntimeUpdate}, 0)
 
 
 @dataclass_transform()
 def _watch_runtime_update[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Watch: WatchBlock.RuntimeUpdate}, 0)
+    return create_global(cls, {Mode.WATCH: WatchBlock.RuntimeUpdate}, 0)
+
+
+@dataclass_transform()
+def _preview_runtime_canvas[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.PREVIEW: PreviewBlock.RuntimeCanvas}, 0)
 
 
 @dataclass_transform()
 def _tutorial_runtime_update[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Tutorial: TutorialBlock.RuntimeUpdate}, 0)
+    return create_global(cls, {Mode.TUTORIAL: TutorialBlock.RuntimeUpdate}, 0)
 
 
 @dataclass_transform()
 def _runtime_touch_array[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Play: PlayBlock.RuntimeTouchArray}, 0)
+    return create_global(cls, {Mode.PLAY: PlayBlock.RuntimeTouchArray}, 0)
 
 
 @dataclass_transform()
@@ -129,9 +134,10 @@ def _runtime_skin_transform[T](cls: type[T]) -> T:
     return create_global(
         cls,
         {
-            Mode.Play: PlayBlock.RuntimeSkinTransform,
-            Mode.Watch: WatchBlock.RuntimeSkinTransform,
-            Mode.Tutorial: TutorialBlock.RuntimeSkinTransform,
+            Mode.PLAY: PlayBlock.RuntimeSkinTransform,
+            Mode.WATCH: WatchBlock.RuntimeSkinTransform,
+            Mode.PREVIEW: PreviewBlock.RuntimeSkinTransform,
+            Mode.TUTORIAL: TutorialBlock.RuntimeSkinTransform,
         },
         0,
     )
@@ -142,9 +148,9 @@ def _runtime_particle_transform[T](cls: type[T]) -> T:
     return create_global(
         cls,
         {
-            Mode.Play: PlayBlock.RuntimeParticleTransform,
-            Mode.Watch: WatchBlock.RuntimeParticleTransform,
-            Mode.Tutorial: TutorialBlock.RuntimeParticleTransform,
+            Mode.PLAY: PlayBlock.RuntimeParticleTransform,
+            Mode.WATCH: WatchBlock.RuntimeParticleTransform,
+            Mode.TUTORIAL: TutorialBlock.RuntimeParticleTransform,
         },
         0,
     )
@@ -155,55 +161,84 @@ def _runtime_background[T](cls: type[T]) -> T:
     return create_global(
         cls,
         {
-            Mode.Play: PlayBlock.RuntimeBackground,
-            Mode.Watch: WatchBlock.RuntimeBackground,
-            Mode.Tutorial: TutorialBlock.RuntimeBackground,
+            Mode.PLAY: PlayBlock.RuntimeBackground,
+            Mode.WATCH: WatchBlock.RuntimeBackground,
+            Mode.TUTORIAL: TutorialBlock.RuntimeBackground,
         },
         0,
     )
 
 
 @dataclass_transform()
-def _runtime_ui[T](cls: type[T]) -> T:
-    return create_global(
-        cls,
-        {
-            Mode.Play: PlayBlock.RuntimeUI,
-            Mode.Watch: WatchBlock.RuntimeUI,
-            Mode.Tutorial: TutorialBlock.RuntimeUI,
-            Mode.Preview: PreviewBlock.RuntimeUI,
-        },
-        0,
-    )
+def _play_runtime_ui[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.PLAY: PlayBlock.RuntimeUI}, 0)
 
 
 @dataclass_transform()
-def _runtime_ui_configuration[T](cls: type[T]) -> T:
-    return create_global(
-        cls,
-        {
-            Mode.Play: PlayBlock.RuntimeUIConfiguration,
-            Mode.Watch: WatchBlock.RuntimeUIConfiguration,
-            Mode.Tutorial: TutorialBlock.RuntimeUIConfiguration,
-            Mode.Preview: PreviewBlock.RuntimeUIConfiguration,
-        },
-        0,
-    )
+def _watch_runtime_ui[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.WATCH: WatchBlock.RuntimeUI}, 0)
+
+
+@dataclass_transform()
+def _tutorial_runtime_ui[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.TUTORIAL: TutorialBlock.RuntimeUI}, 0)
+
+
+@dataclass_transform()
+def _preview_runtime_ui[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.PREVIEW: PreviewBlock.RuntimeUI}, 0)
+
+
+@dataclass_transform()
+def _play_runtime_ui_configuration[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.PLAY: PlayBlock.RuntimeUIConfiguration}, 0)
+
+
+@dataclass_transform()
+def _watch_runtime_ui_configuration[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.WATCH: WatchBlock.RuntimeUIConfiguration}, 0)
+
+
+@dataclass_transform()
+def _tutorial_runtime_ui_configuration[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.TUTORIAL: TutorialBlock.RuntimeUIConfiguration}, 0)
+
+
+@dataclass_transform()
+def _preview_runtime_ui_configuration[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.PREVIEW: PreviewBlock.RuntimeUIConfiguration}, 0)
 
 
 @dataclass_transform()
 def _tutorial_instruction[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Tutorial: TutorialBlock.TutorialInstruction}, 0)
+    return create_global(cls, {Mode.TUTORIAL: TutorialBlock.TutorialInstruction}, 0)
 
 
 @dataclass_transform()
 def level_memory[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Play: PlayBlock.LevelMemory, Mode.Watch: WatchBlock.LevelMemory}, None)
+    return create_global(
+        cls,
+        {
+            Mode.PLAY: PlayBlock.LevelMemory,
+            Mode.WATCH: WatchBlock.LevelMemory,
+            Mode.TUTORIAL: TutorialBlock.TutorialMemory,
+        },
+        None,
+    )
 
 
 @dataclass_transform()
 def level_data[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Play: PlayBlock.LevelData, Mode.Watch: WatchBlock.LevelData}, None)
+    return create_global(
+        cls,
+        {
+            Mode.PLAY: PlayBlock.LevelData,
+            Mode.WATCH: WatchBlock.LevelData,
+            Mode.PREVIEW: PreviewBlock.PreviewData,
+            Mode.TUTORIAL: TutorialBlock.TutorialData,
+        },
+        None,
+    )
 
 
 # level_option is handled by the options decorator
@@ -212,12 +247,12 @@ def level_data[T](cls: type[T]) -> T:
 
 @dataclass_transform()
 def _level_score[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Play: PlayBlock.LevelScore, Mode.Watch: WatchBlock.LevelScore}, 0)
+    return create_global(cls, {Mode.PLAY: PlayBlock.LevelScore, Mode.WATCH: WatchBlock.LevelScore}, 0)
 
 
 @dataclass_transform()
 def _level_life[T](cls: type[T]) -> T:
-    return create_global(cls, {Mode.Play: PlayBlock.LevelLife, Mode.Watch: WatchBlock.LevelLife}, 0)
+    return create_global(cls, {Mode.PLAY: PlayBlock.LevelLife, Mode.WATCH: WatchBlock.LevelLife}, 0)
 
 
 # engine_rom is handled by the compiler