sonolus.py 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

sonolus/backend/finalize.py

@@ -1,3 +1,5 @@
+from math import isfinite, isinf, isnan
+
 from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet
 from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
 from sonolus.backend.ops import Op
@@ -54,10 +56,20 @@ def cfg_to_engine_node(entry: BasicBlock):
 
 def ir_to_engine_node(stmt) -> EngineNode:
     match stmt:
-        case int() | float():
-            return ConstantNode(value=float(stmt))
-        case IRConst(value=int(value) | float(value)):
-            return ConstantNode(value=value)
+        case int(value) | float(value) | IRConst(value=int(value) | float(value)):
+            value = float(value)
+            if value.is_integer():
+                return ConstantNode(value=int(value))
+            elif isfinite(value):
+                return ConstantNode(value=value)
+            elif isinf(value):
+                # Read values from ROM
+                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=1 if value > 0 else 2)])
+            elif isnan(value):
+                # Read value from ROM
+                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=0)])
+            else:
+                raise ValueError(f"Invalid constant value: {value}")
         case IRPureInstr(op=op, args=args) | IRInstr(op=op, args=args):
             return FunctionNode(func=op, args=[ir_to_engine_node(arg) for arg in args])
         case IRGet(place=place):

sonolus/backend/visitor.py

@@ -359,7 +359,7 @@ class Visitor(ast.NodeVisitor):
         self.loop_head_ctxs.append(header_ctx)
         self.break_ctxs.append([])
         set_ctx(header_ctx)
-        has_next = self.ensure_boolean_num(self.handle_call(node, iterator.has_next))
+        has_next = self.convert_to_boolean_num(node, self.handle_call(node, iterator.has_next))
         if has_next._is_py_() and not has_next._as_py_():
             # The loop will never run, continue after evaluating the condition
             self.loop_head_ctxs.pop()
@@ -400,7 +400,7 @@ class Visitor(ast.NodeVisitor):
         self.loop_head_ctxs.append(header_ctx)
         self.break_ctxs.append([])
         set_ctx(header_ctx)
-        test = self.ensure_boolean_num(self.visit(node.test))
+        test = self.convert_to_boolean_num(node.test, self.visit(node.test))
         if test._is_py_():
             if test._as_py_():
                 # The loop will run until a break / return
@@ -454,7 +454,7 @@ class Visitor(ast.NodeVisitor):
         set_ctx(after_ctx)
 
     def visit_If(self, node):
-        test = self.ensure_boolean_num(self.visit(node.test))
+        test = self.convert_to_boolean_num(node.test, self.visit(node.test))
 
         if test._is_py_():
             if test._as_py_():
@@ -507,7 +507,9 @@ class Visitor(ast.NodeVisitor):
                 set_ctx(false_ctx)
                 continue
             set_ctx(true_ctx)
-            guard = self.ensure_boolean_num(self.visit(case.guard)) if case.guard else validate_value(True)
+            guard = (
+                self.convert_to_boolean_num(case.guard, self.visit(case.guard)) if case.guard else validate_value(True)
+            )
             if guard._is_py_():
                 if guard._as_py_():
                     for stmt in case.body:
@@ -544,7 +546,7 @@ class Visitor(ast.NodeVisitor):
         match pattern:
             case ast.MatchValue(value=value):
                 value = self.visit(value)
-                test = self.ensure_boolean_num(validate_value(subject == value))
+                test = self.convert_to_boolean_num(pattern, validate_value(subject == value))
                 if test._is_py_():
                     if test._as_py_():
                         return ctx(), ctx().into_dead()
@@ -574,7 +576,7 @@ class Visitor(ast.NodeVisitor):
                 target_len = len(patterns)
                 if not (isinstance(subject, Sequence | TupleImpl)):
                     return ctx().into_dead(), ctx()
-                length_test = self.ensure_boolean_num(validate_value(_len(subject) == target_len))
+                length_test = self.convert_to_boolean_num(pattern, validate_value(_len(subject) == target_len))
                 ctx_init = ctx()
                 if not length_test._is_py_():
                     ctx_init.test = length_test.ir()
@@ -739,7 +741,7 @@ class Visitor(ast.NodeVisitor):
     def visit_UnaryOp(self, node):
         operand = self.visit(node.operand)
         if isinstance(node.op, ast.Not):
-            return self.ensure_boolean_num(operand).not_()
+            return self.convert_to_boolean_num(node, operand).not_()
         op = unary_ops[type(node.op)]
         if operand._is_py_():
             operand_py = operand._as_py_()
@@ -768,7 +770,7 @@ class Visitor(ast.NodeVisitor):
         return validate_value(fn)
 
     def visit_IfExp(self, node):
-        test = self.ensure_boolean_num(self.visit(node.test))
+        test = self.convert_to_boolean_num(node.test, self.visit(node.test))
 
         if test._is_py_():
             if test._as_py_():
@@ -1076,7 +1078,7 @@ class Visitor(ast.NodeVisitor):
 
     def handle_call[**P, R](
         self, node: ast.stmt | ast.expr, fn: Callable[P, R], /, *args: P.args, **kwargs: P.kwargs
-    ) -> R:
+    ) -> R | Value:
         """Handles a call to the given callable."""
         self.active_ctx = ctx()
         if (
@@ -1127,6 +1129,20 @@ class Visitor(ast.NodeVisitor):
             raise TypeError(f"Invalid type where a bool (Num) was expected: {type(value).__name__}")
         return value
 
+    def convert_to_boolean_num(self, node, value: Value) -> Num:
+        if _is_num(value):
+            return value
+        if hasattr(type(value), "__bool__"):
+            return self.ensure_boolean_num(self.handle_call(node, type(value).__bool__, validate_value(value)))
+        if hasattr(type(value), "__len__"):
+            length = self.handle_call(node, type(value).__len__, validate_value(value))
+            if not _is_num(length):
+                raise TypeError(f"Invalid type for __len__: {type(length).__name__}")
+            if length._is_py_():
+                return Num._accept_(length._as_py_() > 0)
+            return length > Num._accept_(0)
+        raise TypeError(f"Converting {type(value).__name__} to bool is not supported")
+
     def arguments_to_signature(self, arguments: ast.arguments) -> inspect.Signature:
         parameters: list[inspect.Parameter] = []
         pos_only_count = len(arguments.posonlyargs)

sonolus/script/archetype.py

@@ -312,7 +312,7 @@ class StandardImport:
 def callback[T: Callable](*, order: int = 0) -> Callable[[T], T]:
     """Annotate a callback with its order.
 
-    Callbacks are execute from lowest to highest order. By default, callbacks have an order of 0.
+    Callbacks are executed from lowest to highest order. By default, callbacks have an order of 0.
 
     Usage:
         ```python
@@ -338,9 +338,9 @@ class _ArchetypeSelfData:
 
 
 class _ArchetypeReferenceData:
-    index: Num
+    index: int
 
-    def __init__(self, index: Num):
+    def __init__(self, index: int):
         self.index = index
 
 
@@ -416,21 +416,21 @@ class _BaseArchetype:
 
     @classmethod
     @meta_fn
-    def at(cls, index: Num) -> Self:
+    def at(cls, index: int) -> Self:
         result = cls._new()
         result._data_ = _ArchetypeReferenceData(index=Num._accept_(index))
         return result
 
     @classmethod
     @meta_fn
-    def is_at(cls, index: Num) -> bool:
+    def is_at(cls, index: int) -> bool:
         if not ctx():
             raise RuntimeError("is_at is only available during compilation")
         return entity_info_at(index).archetype_id == cls.id()
 
     @classmethod
     @meta_fn
-    def id(cls):
+    def id(cls) -> int:
         if not ctx():
             raise RuntimeError("Archetype id is only available during compilation")
         result = ctx().global_state.archetypes.get(cls)
@@ -549,11 +549,19 @@ class _BaseArchetype:
                     metadata = _annotation_defaults.get(metadata, metadata)
                 if isinstance(metadata, _ArchetypeFieldInfo):
                     if field_info is not None:
-                        raise TypeError(
-                            f"Unexpected multiple field annotations for '{name}', "
-                            f"expected exactly one of imported, exported, entity_memory, or shared_memory"
-                        )
-                    field_info = metadata
+                        if field_info.storage == metadata.storage and field_info.name is None:
+                            field_info = metadata
+                        elif field_info.storage == metadata.storage and (
+                            metadata.name is None or field_info.name == metadata.name
+                        ):
+                            pass
+                        else:
+                            raise TypeError(
+                                f"Unexpected multiple field annotations for '{name}', "
+                                f"expected exactly one of imported, exported, entity_memory, or shared_memory"
+                            )
+                    else:
+                        field_info = metadata
             if field_info is None:
                 raise TypeError(
                     f"Missing field annotation for '{name}', "
@@ -880,7 +888,7 @@ class WatchArchetype(_BaseArchetype):
             case _ArchetypeSelfData():
                 return _deref(ctx().blocks.EntityInfo, 0, WatchEntityInfo)
             case _ArchetypeReferenceData(index=index):
-                return _deref(ctx().blocks.EntityInfoArray, index * WatchEntityInfo._size_(), PlayEntityInfo)
+                return _deref(ctx().blocks.EntityInfoArray, index * WatchEntityInfo._size_(), WatchEntityInfo)
             case _:
                 raise RuntimeError("Info is only accessible from the entity itself")
 
@@ -984,7 +992,7 @@ class PreviewArchetype(_BaseArchetype):
 
 
 @meta_fn
-def entity_info_at(index: Num) -> PlayEntityInfo | WatchEntityInfo | PreviewEntityInfo:
+def entity_info_at(index: int) -> PlayEntityInfo | WatchEntityInfo | PreviewEntityInfo:
     """Retrieve entity info of the entity at the given index.
 
     Available in play, watch, and preview mode.
@@ -1039,24 +1047,24 @@ class PreviewEntityInfo(Record):
 class ArchetypeLife(Record):
     """How an entity contributes to life."""
 
-    perfect_increment: Num
+    perfect_increment: int
     """Life increment for a perfect judgment."""
 
-    great_increment: Num
+    great_increment: int
     """Life increment for a great judgment."""
 
-    good_increment: Num
+    good_increment: int
     """Life increment for a good judgment."""
 
-    miss_increment: Num
+    miss_increment: int
     """Life increment for a miss judgment."""
 
     def update(
         self,
-        perfect_increment: Num | None = None,
-        great_increment: Num | None = None,
-        good_increment: Num | None = None,
-        miss_increment: Num | None = None,
+        perfect_increment: int | None = None,
+        great_increment: int | None = None,
+        good_increment: int | None = None,
+        miss_increment: int | None = None,
     ):
         """Update the life increments."""
         if perfect_increment is not None:
@@ -1106,10 +1114,20 @@ class EntityRef[A: _BaseArchetype](Record):
         """Return a new reference with the given archetype type."""
         return EntityRef[archetype](index=self.index)
 
+    @meta_fn
     def get(self) -> A:
         """Get the entity."""
+        if ref := getattr(self, "_ref_", None):
+            return ref
         return self.archetype().at(self.index)
 
+    @meta_fn
+    def get_as(self, archetype: type[_BaseArchetype]) -> _BaseArchetype:
+        """Get the entity as the given archetype type."""
+        if getattr(archetype, "_ref_", None):
+            raise TypeError("Using get_as in level data is not supported.")
+        return self.with_archetype(archetype).get()
+
     def archetype_matches(self) -> bool:
         """Check if entity at the index is precisely of the archetype."""
         return self.index >= 0 and self.archetype().is_at(self.index)
@@ -1117,7 +1135,7 @@ class EntityRef[A: _BaseArchetype](Record):
     def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[DataValue | str]:
         ref = getattr(self, "_ref_", None)
         if ref is None:
-            return [self.index]
+            return Num._accept_(self.index)._to_list_()
         else:
             if ref not in level_refs:
                 raise KeyError("Reference to entity not in level data")

sonolus/script/array.py

@@ -5,7 +5,7 @@ from typing import Any, Self, final
 
 from sonolus.backend.ir import IRConst, IRSet
 from sonolus.backend.place import BlockPlace
-from sonolus.script.array_like import ArrayLike
+from sonolus.script.array_like import ArrayLike, get_positive_index
 from sonolus.script.debug import assert_unreachable
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.error import InternalError
@@ -18,6 +18,7 @@ from sonolus.script.num import Num
 class ArrayMeta(type):
     @meta_fn
     def __pos__[T](cls: type[T]) -> T:
+        """Create a zero-initialized array instance."""
         return cls._zero_()
 
 
@@ -30,6 +31,7 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
         array_1 = Array(1, 2, 3)
         array_2 = Array[int, 0]()
         array_3 = +Array[int, 3]  # Create a zero-initialized array
+        array_4 = +array_1  # Create a copy of array_1
         ```
     """
 
@@ -185,8 +187,8 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
         return self.size()
 
     @meta_fn
-    def __getitem__(self, index: Num) -> T:
-        index: Num = Num._accept_(index)
+    def __getitem__(self, index: int) -> T:
+        index: Num = Num._accept_(get_positive_index(index, self.size()))
         if index._is_py_() and 0 <= index._as_py_() < self.size():
             const_index = index._as_py_()
             if isinstance(const_index, float) and not const_index.is_integer():
@@ -229,8 +231,8 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
                 raise InternalError("Unexpected array value")
 
     @meta_fn
-    def __setitem__(self, index: Num, value: T):
-        index: Num = Num._accept_(index)
+    def __setitem__(self, index: int, value: T):
+        index: Num = Num._accept_(get_positive_index(index, self.size()))
         value = self.element_type()._accept_(value)
         if ctx():
             if isinstance(self._value, list):
@@ -303,6 +305,7 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
         else:
             return f"{type(self).__name__}({', '.join(repr(self[i]) for i in range(self.size()))})"
 
+    @meta_fn
     def __pos__(self) -> Self:
         """Return a copy of the array."""
         return self._copy_()

sonolus/script/array_like.py

@@ -5,6 +5,8 @@ from abc import abstractmethod
 from collections.abc import Callable
 from typing import Any
 
+from sonolus.script.internal.context import ctx
+from sonolus.script.internal.impl import meta_fn
 from sonolus.script.iterator import SonolusIterator
 from sonolus.script.num import Num
 from sonolus.script.record import Record
@@ -24,10 +26,10 @@ class ArrayLike[T]:
             def __len__(self) -> int:
                 ...
 
-            def __getitem__(self, index: Num) -> T:
+            def __getitem__(self, index: int) -> T:
                 ...
 
-            def __setitem__(self, index: Num, value: T):
+            def __setitem__(self, index: int, value: T):
                 ...
         ```
     """
@@ -39,7 +41,7 @@ class ArrayLike[T]:
         """Return the length of the array."""
 
     @abstractmethod
-    def __getitem__(self, index: Num) -> T:
+    def __getitem__(self, index: int) -> T:
         """Return the item at the given index.
 
         Args:
@@ -47,7 +49,7 @@ class ArrayLike[T]:
         """
 
     @abstractmethod
-    def __setitem__(self, index: Num, value: T):
+    def __setitem__(self, index: int, value: T):
         """Set the value of the item at the given index.
 
         Args:
@@ -76,10 +78,10 @@ class ArrayLike[T]:
         """Return a reversed view of the array."""
         return _ArrayReverser(self)
 
-    def _enumerate_(self, start: Num = 0) -> SonolusIterator[T]:
+    def _enumerate_(self, start: int = 0) -> SonolusIterator[T]:
         return _ArrayEnumerator(0, start, self)
 
-    def index(self, value: T, start: Num = 0, stop: Num | None = None) -> Num:
+    def index(self, value: T, start: int = 0, stop: int | None = None) -> int:
         """Return the index of the value in the array equal to the given value.
 
         Args:
@@ -96,7 +98,7 @@ class ArrayLike[T]:
             i += 1
         return -1
 
-    def count(self, value: T) -> Num:
+    def count(self, value: T) -> int:
         """Return the number of elements in the array equal to the given value.
 
         Args:
@@ -110,7 +112,7 @@ class ArrayLike[T]:
             i += 1
         return count
 
-    def last_index(self, value: T) -> Num:
+    def last_index(self, value: T) -> int:
         """Return the last index of the value in the array equal to the given value.
 
         Args:
@@ -123,7 +125,7 @@ class ArrayLike[T]:
             i -= 1
         return -1
 
-    def index_of_max(self, *, key: Callable[T, Any] | None = None) -> Num:
+    def index_of_max(self, *, key: Callable[[T], Any] | None = None) -> int:
         """Return the index of the maximum value in the array.
 
         Args:
@@ -141,7 +143,7 @@ class ArrayLike[T]:
             i += 1
         return max_index
 
-    def index_of_min(self, *, key: Callable[T, Any] | None = None) -> Num:
+    def index_of_min(self, *, key: Callable[[T], Any] | None = None) -> int:
         """Return the index of the minimum value in the array.
 
         Args:
@@ -159,17 +161,17 @@ class ArrayLike[T]:
             i += 1
         return min_index
 
-    def _max_(self, key: Callable[T, Any] | None = None) -> T:
+    def _max_(self, key: Callable[[T], Any] | None = None) -> T:
         index = self.index_of_max(key=key)
         assert index != -1
         return self[index]
 
-    def _min_(self, key: Callable[T, Any] | None = None) -> T:
+    def _min_(self, key: Callable[[T], Any] | None = None) -> T:
         index = self.index_of_min(key=key)
         assert index != -1
         return self[index]
 
-    def swap(self, i: Num, j: Num, /):
+    def swap(self, i: int, j: int, /):
         """Swap the values at the given indices.
 
         Args:
@@ -180,7 +182,7 @@ class ArrayLike[T]:
         self[i] = self[j]
         self[j] = temp
 
-    def sort(self, *, key: Callable[T, Any] | None = None, reverse: bool = False):
+    def sort(self, *, key: Callable[[T], Any] | None = None, reverse: bool = False):
         """Sort the values in the array in place.
 
         Args:
@@ -214,7 +216,7 @@ def _identity[T](value: T) -> T:
     return value
 
 
-def _insertion_sort[T](array: ArrayLike[T], start: Num, end: Num, key: Callable[T, Any], reverse: bool):
+def _insertion_sort[T](array: ArrayLike[T], start: int, end: int, key: Callable[[T], Any], reverse: bool):
     i = start + 1
     if reverse:
         while i < end:
@@ -232,7 +234,7 @@ def _insertion_sort[T](array: ArrayLike[T], start: Num, end: Num, key: Callable[
             i += 1
 
 
-def _heapify[T](array: ArrayLike[T], end: Num, index: Num, reverse: bool):
+def _heapify[T](array: ArrayLike[T], end: int, index: int, reverse: bool):
     while True:
         left = index * 2 + 1
         right = left + 1
@@ -247,7 +249,7 @@ def _heapify[T](array: ArrayLike[T], end: Num, index: Num, reverse: bool):
         index = largest
 
 
-def _heap_sort[T](array: ArrayLike[T], start: Num, end: Num, reverse: bool):
+def _heap_sort[T](array: ArrayLike[T], start: int, end: int, reverse: bool):
     i = end // 2 - 1
     while i >= start:
         _heapify(array, end, i, reverse)
@@ -279,10 +281,10 @@ class _ArrayReverser[V: ArrayLike](Record, ArrayLike):
     def __len__(self) -> int:
         return len(self.array)
 
-    def __getitem__(self, index: Num) -> V:
+    def __getitem__(self, index: int) -> V:
         return self.array[len(self) - 1 - index]
 
-    def __setitem__(self, index: Num, value: V):
+    def __setitem__(self, index: int, value: V):
         self.array[len(self) - 1 - index] = value
 
     def reversed(self) -> ArrayLike[V]:
@@ -302,3 +304,26 @@ class _ArrayEnumerator[V: ArrayLike](Record, SonolusIterator):
 
     def advance(self):
         self.i += 1
+
+
+@meta_fn
+def get_positive_index(index: int, length: int) -> int:
+    """Get the positive index for the given index in the array of the given length.
+
+    This is used to convert negative indixes relative to the end of the array to positive indices.
+
+    Args:
+        index: The index to convert.
+        length: The length of the array.
+
+    Returns:
+        The positive index.
+    """
+    if not ctx():
+        return index if index >= 0 else index + length
+    index = Num._accept_(index)
+    length = Num._accept_(length)
+    if index._is_py_() and length._is_py_():
+        return Num._accept_(index._as_py_() + length._as_py_() if index._as_py_() < 0 else index._as_py_())
+    else:
+        return index + (index < 0) * length

sonolus/script/containers.py

@@ -2,10 +2,11 @@ from __future__ import annotations
 
 from sonolus.backend.visitor import compile_and_call
 from sonolus.script.array import Array
-from sonolus.script.array_like import ArrayLike
+from sonolus.script.array_like import ArrayLike, get_positive_index
 from sonolus.script.debug import error
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.impl import meta_fn
+from sonolus.script.interval import clamp
 from sonolus.script.iterator import SonolusIterator
 from sonolus.script.num import Num
 from sonolus.script.pointer import _deref
@@ -140,11 +141,11 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             assert p == Pair(5, 6)  # The value of p has changed
             ```
         """
-        return self._array[item]
+        return self._array[get_positive_index(item, len(self))]
 
     def __setitem__(self, key: int, value: T):
         """Update the element at the given index."""
-        self._array[key] = value
+        self._array[get_positive_index(key, len(self))] = value
 
     def __delitem__(self, key: int):
         """Remove the element at the given index."""
@@ -190,6 +191,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         """
         if index is None:
             index = self._size - 1
+        index = get_positive_index(index, len(self))
         assert 0 <= index < self._size
         value = copy(self._array[index])
         self._size -= 1
@@ -207,7 +209,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             index: The index at which to insert the value. Must be in the range [0, size].
             value: The value to insert.
         """
-        assert 0 <= index <= self._size
+        index = clamp(get_positive_index(index, len(self)), 0, self._size)
         assert self._size < len(self._array)
         self._size += 1
         for i in range(self._size - 1, index, -1):
@@ -329,6 +331,7 @@ class ArrayPointer[T](Record, ArrayLike[T]):
 
     @meta_fn
     def _get_item(self, item: int) -> T:
+        item = get_positive_index(item, self.size)
         if not ctx():
             raise TypeError("ArrayPointer values cannot be accessed outside of a context")
         return _deref(
@@ -536,6 +539,23 @@ class ArrayMap[K, V, Capacity](Record):
         self._array[self._size] = _ArrayMapEntry(key, value)
         self._size += 1
 
+    def __delitem__(self, key: K):
+        """Remove the key-value pair associated with the given key.
+
+        Must be called with a key that is present in the map.
+
+        Args:
+            key: The key to remove
+        """
+        for i in range(self._size):
+            entry = self._array[i]
+            if entry.key == key:
+                self._size -= 1
+                if i < self._size:
+                    self._array[i] = self._array[self._size]
+                return
+        error()
+
     def __contains__(self, key: K) -> bool:
         """Return whether the given key is present in the map.
 

sonolus/script/debug.py

@@ -57,7 +57,7 @@ def static_error(message: str | None = None) -> Never:
 
 
 @meta_fn
-def debug_log(value: Num):
+def debug_log(value: int | float | bool):
     """Log a value in debug mode."""
     if debug_log_callback.get(None):
         return debug_log_callback.get()(value)
@@ -66,7 +66,7 @@ def debug_log(value: Num):
 
 
 @native_function(Op.DebugLog)
-def _debug_log(value: Num):
+def _debug_log(value: int | float | bool):
     print(f"[DEBUG] {value}")
     return 0
 
@@ -77,13 +77,13 @@ def debug_pause():
     input("[DEBUG] Paused")
 
 
-def assert_true(value: Num, message: str | None = None):
+def assert_true(value: int | float | bool, message: str | None = None):
     message = message if message is not None else "Assertion failed"
     if not value:
         error(message)
 
 
-def assert_false(value: Num, message: str | None = None):
+def assert_false(value: int | float | bool, message: str | None = None):
     message = message if message is not None else "Assertion failed"
     if value:
         error(message)

sonolus/script/engine.py

@@ -217,7 +217,7 @@ class WatchMode:
 
         for archetype in self.archetypes:
             if not issubclass(archetype, WatchArchetype):
-                raise ValueError(f"archetype {archetype} is not a PlayArchetype")
+                raise ValueError(f"archetype {archetype} is not a WatchArchetype")
 
 
 class PreviewMode:
@@ -239,7 +239,7 @@ class PreviewMode:
 
         for archetype in self.archetypes:
             if not issubclass(archetype, PreviewArchetype):
-                raise ValueError(f"archetype {archetype} is not a BaseArchetype")
+                raise ValueError(f"archetype {archetype} is not a PreviewArchetype")
 
 
 class TutorialMode:

sonolus/script/instruction.py

@@ -97,7 +97,7 @@ def instructions[T](cls: type[T]) -> T | TutorialInstructions:
         annotation_values = annotation.__metadata__
         if annotation_type is not Instruction:
             raise TypeError(
-                f"Invalid annotation for instruction: {annotation}, expected annotation of type InstructionText"
+                f"Invalid annotation for instruction: {annotation}, expected annotation of type Instruction"
             )
         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")