sonolus.py 0.9.3__py3-none-any.whl → 0.10.1__py3-none-any.whl

sonolus/script/bucket.py

@@ -156,7 +156,7 @@ class Bucket(Record):
         """The judgment window of the bucket."""
         if not ctx():
             raise RuntimeError("Bucket window access outside of compilation")
-        match ctx().global_state.mode:
+        match ctx().mode_state.mode:
             case Mode.PLAY:
                 return _deref(ctx().blocks.LevelBucket, self.id * JudgmentWindow._size_(), JudgmentWindow)
             case Mode.WATCH:

sonolus/script/containers.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import Self
 
-from sonolus.backend.visitor import compile_and_call
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike, get_positive_index
 from sonolus.script.debug import error
@@ -144,11 +143,11 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             assert p == Pair(5, 6)  # The value of p has changed
             ```
         """
-        return self._array[get_positive_index(item, len(self))]
+        return self._array.get_unchecked(get_positive_index(item, self._size))
 
     def __setitem__(self, key: int, value: T):
         """Update the element at the given index."""
-        self._array[get_positive_index(key, len(self))] = value
+        self._array.set_unchecked(get_positive_index(key, self._size), value)
 
     def __delitem__(self, key: int):
         """Remove the element at the given index."""
@@ -160,8 +159,8 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         Args:
             value: The value to append.
         """
-        assert self._size < len(self._array)
-        self._array[self._size] = value
+        assert self._size < len(self._array), "Array is full"
+        self._array.set_unchecked(self._size, value)
         self._size += 1
 
     def append_unchecked(self, value: T):
@@ -172,7 +171,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         Args:
             value: The value to append.
         """
-        self._array[self._size] = value
+        self._array.set_unchecked(self._size, value)
         self._size += 1
 
     def extend(self, values: ArrayLike[T]):
@@ -181,8 +180,12 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         Args:
             values: The values to append.
         """
-        for value in values:
-            self.append(value)
+        assert self._size + len(values) <= len(self._array), "Array is full"
+        i = 0
+        while i < len(values):
+            self._array.set_unchecked(self._size + i, values[i])
+            i += 1
+        self._size += len(values)
 
     def pop(self, index: int | None = None) -> T:
         """Remove and return a copy of the value at the given index.
@@ -194,13 +197,12 @@ 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])
+        index = get_positive_index(index, self._size)
+        value = copy(self._array.get_unchecked(index))
         self._size -= 1
         if index < self._size:
             for i in range(index, self._size):
-                self._array[i] = self._array[i + 1]
+                self._array.set_unchecked(i, self._array.get_unchecked(i + 1))
         return value
 
     def insert(self, index: int, value: T):
@@ -212,12 +214,12 @@ 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.
         """
-        index = clamp(get_positive_index(index, len(self)), 0, self._size)
-        assert self._size < len(self._array)
+        index = clamp(get_positive_index(index, self._size, include_end=True), 0, self._size)
+        assert self._size < len(self._array), "Array is full"
         self._size += 1
         for i in range(self._size - 1, index, -1):
-            self._array[i] = self._array[i - 1]
-        self._array[index] = value
+            self._array.set_unchecked(i, self._array.get_unchecked(i - 1))
+        self._array.set_unchecked(index, value)
 
     def remove(self, value: T) -> bool:
         """Remove the first occurrence of the given value, returning whether the value was removed.
@@ -277,7 +279,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         if index < 0:
             return False
         if index < self._size - 1:
-            self._array[index] = self._array[self._size - 1]
+            self._array.set_unchecked(index, self._array.get_unchecked(self._size - 1))
         self._size -= 1
         return True
 
@@ -293,7 +295,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             return False
         i = 0
         while i < len(self):
-            if self[i] != other[i]:
+            if self.get_unchecked(i) != other.get_unchecked(i):
                 return False
             i += 1
         return True
@@ -329,12 +331,8 @@ class ArrayPointer[T](Record, ArrayLike[T]):
         """Return the type of the elements in the array."""
         return cls.type_var_value(T)
 
-    def _check_index(self, index: int):
-        assert 0 <= index < self.size
-
     @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(
@@ -344,14 +342,18 @@ class ArrayPointer[T](Record, ArrayLike[T]):
             self.element_type(),
         )
 
+    def __getitem__(self, item) -> T:
+        return self.get_unchecked(get_positive_index(item, self.size))
+
+    def __setitem__(self, key: int, value: T):
+        self.set_unchecked(get_positive_index(key, self.size), value)
+
     @meta_fn
-    def __getitem__(self, item: int) -> T:
-        compile_and_call(self._check_index, item)
+    def get_unchecked(self, item: int) -> T:
         return self._get_item(item)._get_()
 
     @meta_fn
-    def __setitem__(self, key: int, value: T):
-        compile_and_call(self._check_index, key)
+    def set_unchecked(self, key: int, value: T):
         dst = self._get_item(key)
         if self.element_type()._is_value_type_():
             dst._set_(value)
@@ -519,7 +521,7 @@ class ArrayMap[K, V, Capacity](Record):
             ```
         """
         for i in range(self._size):
-            entry = self._array[i]
+            entry = self._array.get_unchecked(i)
             if entry.key == key:
                 return entry.value
         error()
@@ -535,12 +537,12 @@ class ArrayMap[K, V, Capacity](Record):
             value: The value to associate with the key
         """
         for i in range(self._size):
-            entry = self._array[i]
+            entry = self._array.get_unchecked(i)
             if entry.key == key:
                 entry.value = value
                 return
-        assert self._size < self.capacity()
-        self._array[self._size] = _ArrayMapEntry(key, value)
+        assert self._size < self.capacity(), "Map is full"
+        self._array.set_unchecked(self._size, _ArrayMapEntry(key, value))
         self._size += 1
 
     def __delitem__(self, key: K):
@@ -552,11 +554,11 @@ class ArrayMap[K, V, Capacity](Record):
             key: The key to remove
         """
         for i in range(self._size):
-            entry = self._array[i]
+            entry = self._array.get_unchecked(i)
             if entry.key == key:
                 self._size -= 1
                 if i < self._size:
-                    self._array[i] = self._array[self._size]
+                    self._array.set_unchecked(i, self._array.get_unchecked(self._size))
                 return
         error()
 
@@ -570,7 +572,7 @@ class ArrayMap[K, V, Capacity](Record):
             True if the key is present, False otherwise.
         """
         for i in range(self._size):  # noqa: SIM110
-            if self._array[i].key == key:
+            if self._array.get_unchecked(i).key == key:
                 return True
         return False
 
@@ -586,12 +588,12 @@ class ArrayMap[K, V, Capacity](Record):
             The value associated with the key
         """
         for i in range(self._size):
-            entry = self._array[i]
+            entry = self._array.get_unchecked(i)
             if entry.key == key:
                 value = copy(entry.value)
                 self._size -= 1
                 if i < self._size:
-                    self._array[i] = self._array[self._size]
+                    self._array.set_unchecked(i, self._array.get_unchecked(self._size))
                 return value
         error()
 
@@ -606,7 +608,7 @@ class _ArrayMapKeyIterator[K, V, Capacity](Record, SonolusIterator):
 
     def next(self) -> Maybe[K]:
         if self._index < len(self._map):
-            key = self._map._array[self._index].key
+            key = self._map._array.get_unchecked(self._index).key
             self._index += 1
             return Some(key)
         return Nothing
@@ -618,7 +620,7 @@ class _ArrayMapValueIterator[K, V, Capacity](Record, SonolusIterator):
 
     def next(self) -> Maybe[V]:
         if self._index < len(self._map):
-            value = self._map._array[self._index].value
+            value = self._map._array.get_unchecked(self._index).value
             self._index += 1
             return Some(value)
         return Nothing
@@ -630,7 +632,7 @@ class _ArrayMapEntryIterator[K, V, Capacity](Record, SonolusIterator):
 
     def next(self) -> Maybe[tuple[K, V]]:
         if self._index < len(self._map):
-            entry = self._map._array[self._index]
+            entry = self._map._array.get_unchecked(self._index)
             result = (entry.key, entry.value)
             self._index += 1
             return Some(result)

sonolus/script/debug.py

@@ -7,7 +7,7 @@ from sonolus.backend.ops import Op
 from sonolus.backend.optimize.flow import cfg_to_mermaid
 from sonolus.backend.optimize.passes import CompilerPass, OptimizerConfig, run_passes
 from sonolus.backend.optimize.simplify import RenumberVars
-from sonolus.script.internal.context import GlobalContextState, ReadOnlyMemory, ctx, set_ctx
+from sonolus.script.internal.context import ModeContextState, ProjectContextState, ctx, set_ctx
 from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.native import native_function
 from sonolus.script.internal.simulation_context import SimulationContext
@@ -18,17 +18,23 @@ debug_log_callback = ContextVar[Callable[[Num], None]]("debug_log_callback")
 
 @meta_fn
 def error(message: str | None = None) -> Never:  # type: ignore
-    """Raise an error.
+    """Raise an error, and if in a dev build, log a message and pause the game.
 
     This function is used to raise an error during runtime.
     When this happens, the game will pause in debug mode. The current callback will also immediately return 0.
+
+    In non-dev builds, this function will terminate the current callback silently.
+
+    Args:
+        message: The message to log.
     """
     message = validate_value(message)._as_py_() or "Error"  # type: ignore
     if not isinstance(message, str):
         raise ValueError("Expected a string")
     if ctx():
-        debug_log(ctx().map_constant(message))
-        debug_pause()
+        if ctx().project_state.dev:
+            debug_log(ctx().map_debug_message(message))
+            debug_pause()
         terminate()
     else:
         raise RuntimeError(message)
@@ -40,6 +46,9 @@ def static_error(message: str | None = None) -> Never:
 
     This function is used to raise an error during compile-time if the compiler cannot guarantee that
     this function will not be called during runtime.
+
+    Args:
+        message: The message to log.
     """
     message = validate_value(message)._as_py_() or "Error"  # type: ignore
     if not isinstance(message, str):
@@ -69,7 +78,39 @@ def debug_pause():
 
 
 @meta_fn
-def assert_true(value: int | float | bool, message: str | None = None):
+def notify(message: str):
+    """Log a code that can be decoded by the dev server and pause the game if in debug mode and in a dev build.
+
+    Does nothing if not a dev build.
+
+    Args:
+        message: The message to log.
+    """
+    message = validate_value(message)._as_py_()  # type: ignore
+    if not isinstance(message, str):
+        raise ValueError("Expected a string")
+    if ctx():
+        if ctx().project_state.dev:
+            debug_log(ctx().map_debug_message(message))
+            debug_pause()
+    else:
+        print(f"[NOTIFY] {message}")
+
+
+@meta_fn
+def require(value: int | float | bool, message: str | None = None):
+    """Require a condition to be true, or raise an error.
+
+    Similar to assert, but does not get stripped in non-dev builds.
+
+    If in a dev build, this function will log a message and pause the game if the condition is false.
+
+    In non-dev builds, this function will terminate the current callback silently if the condition is false.
+
+    Args:
+        value: The condition to check.
+        message: The message to log if the condition is false.
+    """
     if not ctx():
         if not value:
             raise AssertionError(message if message is not None else "Assertion failed")
@@ -91,6 +132,13 @@ def assert_true(value: int | float | bool, message: str | None = None):
         set_ctx(t_branch)
 
 
+@meta_fn
+def assert_true(value: int | float | bool, message: str | None = None):
+    if ctx() and not ctx().project_state.dev:
+        return
+    require(value, message)
+
+
 def assert_false(value: int | float | bool, message: str | None = None):
     assert_true(not value, message)
 
@@ -156,13 +204,13 @@ def visualize_cfg(
                 RenumberVars(),
             ]
 
-    global_state = GlobalContextState(
+    project_state = ProjectContextState()
+    mode_state = ModeContextState(
         mode,
         {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None,
-        ReadOnlyMemory(),
     )
 
-    cfg = callback_to_cfg(global_state, fn, callback, archetype=archetype)  # type: ignore
+    cfg = callback_to_cfg(project_state, mode_state, fn, callback, archetype=archetype)  # type: ignore
     cfg = run_passes(cfg, passes, OptimizerConfig(mode=mode))
     return cfg_to_mermaid(cfg)
 

sonolus/script/effect.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from typing import Annotated, Any, NewType, dataclass_transform, get_origin
 
 from sonolus.backend.ops import Op
-from sonolus.script.array_like import ArrayLike
+from sonolus.script.array_like import ArrayLike, check_positive_index
 from sonolus.script.debug import static_error
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
@@ -111,7 +111,10 @@ class EffectGroup(Record, ArrayLike[Effect]):
         return self.size
 
     def __getitem__(self, index: int) -> Effect:
-        assert 0 <= index < self.size
+        check_positive_index(index, self.size)
+        return Effect(self.start_id + index)
+
+    def get_unchecked(self, index: int) -> Effect:
         return Effect(self.start_id + index)
 
     def __setitem__(self, index: int, value: Effect) -> None:

sonolus/script/internal/builtin_impls.py

@@ -3,7 +3,7 @@ from typing import Never, assert_never
 from sonolus.backend.ops import Op
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike
-from sonolus.script.debug import error
+from sonolus.script.debug import error, require
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.dict_impl import DictImpl
 from sonolus.script.internal.impl import meta_fn, validate_value
@@ -192,7 +192,7 @@ def _max_num_iterator(iterable, default, key):
     iterator = iterable.__iter__()  # noqa: PLC2801
     initial = iterator.next()
     if initial.is_nothing:
-        assert default is not None
+        require(default is not None, "default must be provided if the iterator is empty")
         return default
     if key is not None:
         result = initial.get_unsafe()
@@ -285,7 +285,7 @@ def _min_num_iterator(iterable, default, key):
     iterator = iterable.__iter__()  # noqa: PLC2801
     initial = iterator.next()
     if initial.is_nothing:
-        assert default is not None
+        require(default is not None, "default must be provided if the iterator is empty")
         return default
     if key is not None:
         result = initial.get_unsafe()
@@ -371,7 +371,7 @@ def _sum(iterable, /, start=0):
 
 
 def _next(iterator):
-    assert isinstance(iterator, SonolusIterator)
+    require(isinstance(iterator, SonolusIterator), "Only subclasses of SonolusIterator are supported as iterators")
     value = iterator.next()
     if value.is_some:
         return value.get_unsafe()

sonolus/script/internal/context.py

@@ -39,19 +39,38 @@ _disabled_debug_config = DebugConfig(
 debug_var = ContextVar("debug_var", default=_disabled_debug_config)
 
 
-class GlobalContextState:
+class ProjectContextState:
+    rom: ReadOnlyMemory
+    const_mappings: dict[Any, int]
+    debug_str_mappings: dict[str, int]
+    lock: Lock
+    dev: bool
+
+    def __init__(
+        self,
+        rom: ReadOnlyMemory | None = None,
+        const_mappings: dict[Any, int] | None = None,
+        debug_str_mappings: dict[str, int] | None = None,
+        dev: bool = False,
+    ):
+        self.rom = ReadOnlyMemory() if rom is None else rom
+        self.const_mappings = {} if const_mappings is None else const_mappings
+        self.debug_str_mappings = {} if debug_str_mappings is None else debug_str_mappings
+        self.lock = Lock()
+        self.dev = dev
+
+
+class ModeContextState:
     archetypes: dict[type, int]
     archetypes_by_name: dict[str, type]
     keys_by_archetype_id: Sequence[int]
     is_scored_by_archetype_id: Sequence[bool]
-    rom: ReadOnlyMemory
-    const_mappings: dict[Any, int]
     environment_mappings: dict[_GlobalInfo, int]
     environment_offsets: dict[Block, int]
     mode: Mode
     lock: Lock
 
-    def __init__(self, mode: Mode, archetypes: dict[type, int] | None = None, rom: ReadOnlyMemory | None = None):
+    def __init__(self, mode: Mode, archetypes: dict[type, int] | None = None):
         from sonolus.script.array import Array
 
         self.archetypes = archetypes or {}
@@ -65,8 +84,6 @@ class GlobalContextState:
             if archetypes
             else Array[bool, Literal[0]]()
         )
-        self.rom = ReadOnlyMemory() if rom is None else rom
-        self.const_mappings = {}
         self.environment_mappings = {}
         self.environment_offsets = {}
         self.mode = mode
@@ -76,16 +93,19 @@ class GlobalContextState:
 class CallbackContextState:
     callback: str
     used_names: dict[str, int]
+    debug_stack: list[str]
     no_eval: bool
 
     def __init__(self, callback: str, no_eval: bool = False):
         self.callback = callback
         self.used_names = {}
+        self.debug_stack = []
         self.no_eval = no_eval
 
 
 class Context:
-    global_state: GlobalContextState
+    project_state: ProjectContextState
+    mode_state: ModeContextState
     callback_state: CallbackContextState
     statements: list[IRStmt]
     test: IRExpr
@@ -96,13 +116,15 @@ class Context:
 
     def __init__(
         self,
-        global_state: GlobalContextState,
+        project_state: ProjectContextState,
+        mode_state: ModeContextState,
         callback_state: CallbackContextState,
         scope: Scope | None = None,
         live: bool = True,
         foldable_constants: dict[TempBlock, list[float | None]] | None = None,
     ):
-        self.global_state = global_state
+        self.project_state = project_state
+        self.mode_state = mode_state
         self.callback_state = callback_state
         self.statements = []
         self.test = IRConst(0)
@@ -114,11 +136,11 @@ class Context:
 
     @property
     def rom(self) -> ReadOnlyMemory:
-        return self.global_state.rom
+        return self.project_state.rom
 
     @property
     def blocks(self) -> type[Block]:
-        return self.global_state.mode.blocks
+        return self.mode_state.mode.blocks
 
     @property
     def callback(self) -> str:
@@ -182,7 +204,8 @@ class Context:
 
     def copy_with_scope(self, scope: Scope) -> Context:
         return Context(
-            global_state=self.global_state,
+            project_state=self.project_state,
+            mode_state=self.mode_state,
             callback_state=self.callback_state,
             scope=scope,
             live=self.live,
@@ -267,25 +290,33 @@ class Context:
                         )
 
     def map_constant(self, value: Any) -> int:
-        with self.global_state.lock:
-            const_mappings = self.global_state.const_mappings
+        with self.project_state.lock:
+            const_mappings = self.project_state.const_mappings
             if value not in const_mappings:
                 const_mappings[value] = len(const_mappings)
             return const_mappings[value]
 
+    def map_debug_message(self, message: str) -> int:
+        with self.project_state.lock:
+            message_with_trace = "\n".join([*self.callback_state.debug_stack, message])
+            debug_str_mappings = self.project_state.debug_str_mappings
+            if message_with_trace not in debug_str_mappings:
+                debug_str_mappings[message_with_trace] = len(debug_str_mappings) + 1
+            return debug_str_mappings[message_with_trace]
+
     def get_global_base(self, value: _GlobalInfo | _GlobalPlaceholder) -> BlockPlace:
-        with self.global_state.lock:
-            block = value.blocks.get(self.global_state.mode)
+        with self.mode_state.lock:
+            block = value.blocks.get(self.mode_state.mode)
             if block is None:
-                raise RuntimeError(f"Global {value} is not available in '{self.global_state.mode.name}' mode")
-            if value not in self.global_state.environment_mappings:
+                raise RuntimeError(f"Global {value} is not available in '{self.mode_state.mode.name}' mode")
+            if value not in self.mode_state.environment_mappings:
                 if value.offset is None:
-                    offset = self.global_state.environment_offsets.get(block, 0)
-                    self.global_state.environment_mappings[value] = offset
-                    self.global_state.environment_offsets[block] = offset + value.size
+                    offset = self.mode_state.environment_offsets.get(block, 0)
+                    self.mode_state.environment_mappings[value] = offset
+                    self.mode_state.environment_offsets[block] = offset + value.size
                 else:
-                    self.global_state.environment_mappings[value] = value.offset
-            return BlockPlace(block, self.global_state.environment_mappings[value])
+                    self.mode_state.environment_mappings[value] = value.offset
+            return BlockPlace(block, self.mode_state.environment_mappings[value])
 
     @classmethod
     def meet(cls, contexts: list[Context]) -> Context:
@@ -303,10 +334,10 @@ class Context:
         return target
 
     def register_archetype(self, type_: type) -> int:
-        with self.global_state.lock:
-            if type_ not in self.global_state.archetypes:
-                self.global_state.archetypes[type_] = len(self.global_state.archetypes)
-            return self.global_state.archetypes[type_]
+        with self.mode_state.lock:
+            if type_ not in self.mode_state.archetypes:
+                self.mode_state.archetypes[type_] = len(self.mode_state.archetypes)
+            return self.mode_state.archetypes[type_]
 
 
 def ctx() -> Context | Any:  # Using Any to silence type checker warnings if it's None