sonolus.py 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

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

sonolus/script/graphics.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Protocol
+from typing import Protocol, Self
 
 from sonolus.script.record import Record
 from sonolus.script.vec import Vec2
@@ -20,21 +20,12 @@ class Rect(Record):
     l: float  # noqa: E741
 
     @classmethod
-    def from_xywh(cls, x: float, y: float, w: float, h: float) -> Rect:
+    def from_center(cls, center: Vec2, dimensions: Vec2) -> Rect:
         return cls(
-            t=y + h,
-            r=x + w,
-            b=y,
-            l=x,
-        )
-
-    @classmethod
-    def from_center(cls, x: float, y: float, w: float, h: float) -> Rect:
-        return cls(
-            t=y + h / 2,
-            r=x + w / 2,
-            b=y - h / 2,
-            l=x - w / 2,
+            t=center.y + dimensions.y / 2,
+            r=center.x + dimensions.x / 2,
+            b=center.y - dimensions.y / 2,
+            l=center.x - dimensions.x / 2,
         )
 
     @property
@@ -99,19 +90,37 @@ class Rect(Record):
             br=self.br,
         )
 
-    def scale(self, x: float, y: float | None, /):
-        if y is None:
-            y = x
-        self.l *= x
-        self.r *= x
-        self.t *= y
-        self.b *= y
-
-    def translate(self, x: float, y: float, /):
-        self.l += x
-        self.r += x
-        self.t += y
-        self.b += y
+    def scale(self, factor: Vec2, /) -> Self:
+        return Rect(
+            t=self.t * factor.y,
+            r=self.r * factor.x,
+            b=self.b * factor.y,
+            l=self.l * factor.x,
+        )
+
+    def expand(self, expansion: Vec2, /) -> Self:
+        return Rect(
+            t=self.t + expansion.y,
+            r=self.r + expansion.x,
+            b=self.b - expansion.y,
+            l=self.l - expansion.x,
+        )
+
+    def shrink(self, shrinkage: Vec2, /) -> Self:
+        return Rect(
+            t=self.t - shrinkage.y,
+            r=self.r - shrinkage.x,
+            b=self.b + shrinkage.y,
+            l=self.l + shrinkage.x,
+        )
+
+    def translate(self, translation: Vec2, /) -> Self:
+        return Rect(
+            t=self.t + translation.y,
+            r=self.r + translation.x,
+            b=self.b + translation.y,
+            l=self.l + translation.x,
+        )
 
 
 class QuadLike(Protocol):

sonolus/script/instruction.py

@@ -0,0 +1,151 @@
+from dataclasses import dataclass
+from typing import Annotated, Any, NewType, dataclass_transform, get_origin
+
+from sonolus.backend.ops import Op
+from sonolus.script.internal.introspection import get_field_specifiers
+from sonolus.script.internal.native import native_function
+from sonolus.script.record import Record
+from sonolus.script.runtime import _TutorialInstruction
+from sonolus.script.text import StandardText
+from sonolus.script.vec import Vec2
+
+
+class InstructionText(Record):
+    id: int
+
+    def show(self):
+        show_instruction(self)
+
+
+class InstructionIcon(Record):
+    id: int
+
+    def paint(self, position: Vec2, size: float, rotation: float, z: float, a: float):
+        _paint(self.id, position.x, position.y, size, rotation, z, a)
+
+
+@dataclass
+class InstructionTextInfo:
+    name: str
+
+
+@dataclass
+class InstructionIconInfo:
+    name: str
+
+
+def instruction(name: str) -> Any:
+    return InstructionTextInfo(name=name)
+
+
+def instruction_icon(name: str) -> Any:
+    return InstructionIconInfo(name=name)
+
+
+type TutorialInstructions = NewType("TutorialInstructions", Any)
+type TutorialInstructionIcons = NewType("TutorialInstructionIcons", Any)
+
+
+@dataclass_transform()
+def instructions[T](cls: type[T]) -> T | TutorialInstructions:
+    if len(cls.__bases__) != 1:
+        raise ValueError("Instructions class must not inherit from any class (except object)")
+    instance = cls()
+    names = []
+    for i, (name, annotation) in enumerate(get_field_specifiers(cls).items()):
+        if get_origin(annotation) is not Annotated:
+            raise TypeError(f"Invalid annotation for instruction: {annotation}")
+        annotation_type = annotation.__args__[0]
+        annotation_values = annotation.__metadata__
+        if annotation_type is not InstructionText:
+            raise TypeError(
+                f"Invalid annotation for instruction: {annotation}, expected annotation of type InstructionText"
+            )
+        if len(annotation_values) != 1 or not isinstance(annotation_values[0], InstructionTextInfo):
+            raise TypeError(f"Invalid annotation for instruction: {annotation}, expected a single annotation value")
+        instruction_name = annotation_values[0].name
+        names.append(instruction_name)
+        setattr(instance, name, InstructionText(i))
+    instance._instructions_ = names
+    instance._is_comptime_value_ = True
+    return instance
+
+
+@dataclass_transform()
+def instruction_icons[T](cls: type[T]) -> T | TutorialInstructionIcons:
+    if len(cls.__bases__) != 1:
+        raise ValueError("Instruction icons class must not inherit from any class (except object)")
+    instance = cls()
+    names = []
+    for i, (name, annotation) in enumerate(get_field_specifiers(cls).items()):
+        if get_origin(annotation) is not Annotated:
+            raise TypeError(f"Invalid annotation for instruction icon: {annotation}")
+        annotation_type = annotation.__args__[0]
+        annotation_values = annotation.__metadata__
+        if annotation_type is not InstructionIcon:
+            raise TypeError(
+                f"Invalid annotation for instruction icon: {annotation}, expected annotation of type InstructionIcon"
+            )
+        if len(annotation_values) != 1 or not isinstance(annotation_values[0], InstructionIconInfo):
+            raise TypeError(
+                f"Invalid annotation for instruction icon: {annotation}, expected a single annotation value"
+            )
+        icon_name = annotation_values[0].name
+        names.append(icon_name)
+        setattr(instance, name, InstructionIcon(i))
+    instance._instruction_icons_ = names
+    instance._is_comptime_value_ = True
+    return instance
+
+
+class StandardInstruction:
+    TAP = Annotated[InstructionText, instruction(StandardText.TAP)]
+    TAP_HOLD = Annotated[InstructionText, instruction(StandardText.TAP_HOLD)]
+    TAP_RELEASE = Annotated[InstructionText, instruction(StandardText.TAP_RELEASE)]
+    TAP_FLICK = Annotated[InstructionText, instruction(StandardText.TAP_FLICK)]
+    TAP_SLIDE = Annotated[InstructionText, instruction(StandardText.TAP_SLIDE)]
+    HOLD = Annotated[InstructionText, instruction(StandardText.HOLD)]
+    HOLD_SLIDE = Annotated[InstructionText, instruction(StandardText.HOLD_SLIDE)]
+    HOLD_FOLLOW = Annotated[InstructionText, instruction(StandardText.HOLD_FOLLOW)]
+    RELEASE = Annotated[InstructionText, instruction(StandardText.RELEASE)]
+    FLICK = Annotated[InstructionText, instruction(StandardText.FLICK)]
+    SLIDE = Annotated[InstructionText, instruction(StandardText.SLIDE)]
+    SLIDE_FLICK = Annotated[InstructionText, instruction(StandardText.SLIDE_FLICK)]
+    AVOID = Annotated[InstructionText, instruction(StandardText.AVOID)]
+    JIGGLE = Annotated[InstructionText, instruction(StandardText.JIGGLE)]
+
+
+class StandardInstructionIcon:
+    HAND = Annotated[InstructionIcon, instruction_icon("#HAND")]
+    ARROW = Annotated[InstructionIcon, instruction_icon("#ARROW")]
+
+
+@instructions
+class EmptyInstructions:
+    pass
+
+
+@instruction_icons
+class EmptyInstructionIcons:
+    pass
+
+
+@native_function(Op.Paint)
+def _paint(
+    icon_id: int,
+    x: float,
+    y: float,
+    size: float,
+    rotation: float,
+    z: float,
+    a: float,
+):
+    raise NotImplementedError()
+
+
+def show_instruction(inst: InstructionText, /):
+    _TutorialInstruction.text_id = inst.id
+
+
+def clear_instruction():
+    _TutorialInstruction.text_id = -1

sonolus/script/internal/builtin_impls.py

@@ -5,7 +5,7 @@ from sonolus.script.internal.context import ctx
 from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.iterator import ArrayLike, Enumerator, SonolusIterator
 from sonolus.script.math import MATH_BUILTIN_IMPLS
-from sonolus.script.num import Num
+from sonolus.script.num import is_num
 from sonolus.script.range import Range
 
 
@@ -74,7 +74,7 @@ def _max(*args):
         else:
             raise TypeError(f"Unsupported type: {type(iterable)} for max")
     else:
-        if not all(isinstance(arg, Num) for arg in args):
+        if not all(is_num(arg) for arg in args):
             raise TypeError("Arguments to max must be numbers")
         if ctx():
             result = compile_and_call(_max2, args[0], args[1])
@@ -114,7 +114,7 @@ def _min(*args):
         else:
             raise TypeError(f"Unsupported type: {type(iterable)} for min")
     else:
-        if not all(isinstance(arg, Num) for arg in args):
+        if not all(is_num(arg) for arg in args):
             raise TypeError("Arguments to min must be numbers")
         if ctx():
             result = compile_and_call(_min2, args[0], args[1])

sonolus/script/internal/native.py

@@ -6,14 +6,14 @@ from sonolus.backend.ir import IRInstr, IRPureInstr, IRSet
 from sonolus.backend.ops import Op
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.impl import meta_fn, validate_value
-from sonolus.script.num import Num
+from sonolus.script.num import Num, is_num
 
 
 def native_call(op: Op, *args: Num) -> Num:
     if not ctx():
         raise RuntimeError("Unexpected native call")
     args = tuple(validate_value(arg) for arg in args)
-    if not all(isinstance(arg, Num) for arg in args):
+    if not all(is_num(arg) for arg in args):
         raise RuntimeError("All arguments must be of type Num")
     result = ctx().alloc(size=1)
     ctx().add_statements(IRSet(result, (IRPureInstr if op.pure else IRInstr)(op, [arg.ir() for arg in args])))

sonolus/script/interval.py

@@ -55,6 +55,12 @@ class Interval(Record):
     def __and__(self, other: Self) -> Self:
         return Interval(max(self.start, other.start), min(self.end, other.end))
 
+    def shrink(self, value: float | int) -> Self:
+        return Interval(self.start + value, self.end - value)
+
+    def expand(self, value: float | int) -> Self:
+        return Interval(self.start - value, self.end + value)
+
     def lerp(self, x: float, /) -> float:
         return lerp(self.start, self.end, x)
 
@@ -67,6 +73,9 @@ class Interval(Record):
     def unlerp_clamped(self, x: float, /) -> float:
         return unlerp_clamped(self.start, self.end, x)
 
+    def clamp(self, x: float, /) -> float:
+        return clamp(x, self.start, self.end)
+
 
 @native_function(Op.Lerp)
 def lerp(a, b, x, /):
@@ -96,3 +105,8 @@ def remap(a, b, c, d, x, /):
 @native_function(Op.RemapClamped)
 def remap_clamped(a, b, c, d, x, /):
     return c + (d - c) * max(0, min(1, (x - a) / (b - a)))
+
+
+@native_function(Op.Clamp)
+def clamp(x, a, b, /):
+    return max(a, min(b, x))

sonolus/script/iterator.py

@@ -180,6 +180,9 @@ class ArrayReverser[V: ArrayLike](Record, ArrayLike):
     def __setitem__(self, index: Num, value: V):
         self.array[self.size() - 1 - index] = value
 
+    def reversed(self) -> ArrayLike[V]:
+        return self.array
+
 
 class Enumerator[V: SonolusIterator](Record, SonolusIterator):
     i: int

sonolus/script/level.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from sonolus.build.collection import Asset
-from sonolus.script.archetype import PlayArchetype, StandardImport
+from sonolus.script.archetype import PlayArchetype, StandardArchetypeName, StandardImport
 
 
 class Level:
@@ -39,14 +39,14 @@ class LevelData:
 
 
 class BpmChange(PlayArchetype):
-    name = "#BPM_CHANGE"
+    name = StandardArchetypeName.BPM_CHANGE
 
-    beat: StandardImport.Beat
-    bpm: StandardImport.Bpm
+    beat: StandardImport.BEAT
+    bpm: StandardImport.BPM
 
 
 class TimescaleChange(PlayArchetype):
-    name = "#TIMESCALE_CHANGE"
+    name = StandardArchetypeName.TIMESCALE_CHANGE
 
-    beat: StandardImport.Beat
-    timescale: StandardImport.Timescale
+    beat: StandardImport.BEAT
+    timescale: StandardImport.TIMESCALE

sonolus/script/num.py

@@ -1,7 +1,9 @@
 # ruff: noqa: N801
+from __future__ import annotations
+
 import operator
 from collections.abc import Callable, Iterable
-from typing import TYPE_CHECKING, Any, Self, final
+from typing import TYPE_CHECKING, Any, Self, TypeIs, final
 
 from sonolus.backend.ir import IRConst, IRGet, IRPureInstr, IRSet
 from sonolus.backend.ops import Op
@@ -12,14 +14,30 @@ from sonolus.script.internal.impl import meta_fn
 from sonolus.script.internal.value import Value
 
 
+class NumMeta(type):
+    def __instancecheck__(cls, instance):
+        return isinstance(instance, float | int | bool) or is_num(instance)
+
+
+def is_num(value: Any) -> TypeIs[Num]:
+    """Check if a value is a precisely Num instance."""
+    return type.__instancecheck__(Num, value)  # type: ignore # noqa: PLC2801
+
+
 @final
-class _Num(Value):
+class _Num(Value, metaclass=NumMeta):
+    # This works for ints, floats, and bools
+    # Since we don't support complex numbers, real is equal to the original number
+    __match_args__ = ("real",)
+
     data: BlockPlace | float | int | bool
 
     def __init__(self, data: Place | float | int | bool):
+        if isinstance(data, complex):
+            raise TypeError("Cannot create a Num from a complex number")
         if isinstance(data, int):
             data = float(data)
-        if isinstance(data, _Num):
+        if is_num(data):
             raise InternalError("Cannot create a Num from a Num")
         self.data = data
 
@@ -55,7 +73,7 @@ class _Num(Value):
     def _accept_(cls, value: Any) -> Self:
         if not cls._accepts_(value):
             raise TypeError(f"Cannot accept {value}")
-        if isinstance(value, Num):
+        if is_num(value):
             return value
         return cls(value)
 
@@ -368,6 +386,14 @@ class _Num(Value):
     def not_(self) -> Self:
         return self._unary_op(operator.not_, Op.Not)
 
+    @property
+    def real(self) -> Self:
+        return self
+
+    @property
+    def imag(self) -> Self:
+        return 0
+
 
 if TYPE_CHECKING:
 

sonolus/script/options.py

@@ -139,13 +139,13 @@ class OptionField(SonolusDescriptor):
     def __get__(self, instance, owner):
         if ctx():
             match ctx().global_state.mode:
-                case Mode.Play:
+                case Mode.PLAY:
                     block = ctx().blocks.LevelOption
-                case Mode.Watch:
+                case Mode.WATCH:
                     block = ctx().blocks.LevelOption
-                case Mode.Preview:
+                case Mode.PREVIEW:
                     block = ctx().blocks.PreviewOption
-                case Mode.Tutorial:
+                case Mode.TUTORIAL:
                     block = None
                 case _:
                     assert_unreachable()