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

sonolus/script/particle.py

@@ -1,157 +1,157 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Annotated, Any, NewType, dataclass_transform, get_origin
-
-from sonolus.backend.ops import Op
-from sonolus.script.graphics import QuadLike, flatten_quad
-from sonolus.script.internal.introspection import get_field_specifiers
-from sonolus.script.internal.native import native_function
-from sonolus.script.record import Record
-
-
-class Particle(Record):
-    id: int
-
-    def is_available(self) -> bool:
-        return _has_particle_effect(self.id)
-
-    def spawn(self, quad: QuadLike, duration: float, loop: bool = False) -> ParticleHandle:
-        return ParticleHandle(_spawn_particle_effect(self.id, *flatten_quad(quad), duration, loop))
-
-
-class ParticleHandle(Record):
-    id: int
-
-    def move(self, quad: QuadLike) -> None:
-        _move_particle_effect(self.id, *flatten_quad(quad))
-
-    def destroy(self) -> None:
-        _destroy_particle_effect(self.id)
-
-
-@native_function(Op.HasParticleEffect)
-def _has_particle_effect(particle_id: int) -> bool:
-    raise NotImplementedError
-
-
-@native_function(Op.SpawnParticleEffect)
-def _spawn_particle_effect(
-    particle_id: int,
-    x1: float,
-    y1: float,
-    x2: float,
-    y2: float,
-    x3: float,
-    y3: float,
-    x4: float,
-    y4: float,
-    duration: float,
-    loop: bool,
-) -> int:
-    raise NotImplementedError
-
-
-@native_function(Op.MoveParticleEffect)
-def _move_particle_effect(
-    handle: int, x1: float, y1: float, x2: float, y2: float, x3: float, y3: float, x4: float, y4: float
-) -> None:
-    raise NotImplementedError
-
-
-@native_function(Op.DestroyParticleEffect)
-def _destroy_particle_effect(handle: int) -> None:
-    raise NotImplementedError
-
-
-@dataclass
-class ParticleInfo:
-    name: str
-
-
-def particle(name: str) -> Any:
-    return ParticleInfo(name)
-
-
-type Particles = NewType("Particles", Any)
-
-
-@dataclass_transform()
-def particles[T](cls: type[T]) -> T | Particles:
-    if len(cls.__bases__) != 1:
-        raise ValueError("Particles 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 particles: {annotation}")
-        annotation_type = annotation.__args__[0]
-        annotation_values = annotation.__metadata__
-        if annotation_type is not Particle:
-            raise TypeError(f"Invalid annotation for particles: {annotation}, expected annotation of type Particle")
-        if len(annotation_values) != 1 or not isinstance(annotation_values[0], ParticleInfo):
-            raise TypeError(
-                f"Invalid annotation for particles: {annotation}, expected a single string annotation value"
-            )
-        particle_name = annotation_values[0].name
-        names.append(particle_name)
-        setattr(instance, name, Particle(i))
-    instance._particles_ = names
-    instance._is_comptime_value_ = True
-    return instance
-
-
-class StandardParticle:
-    NOTE_CIRCULAR_TAP_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_NEUTRAL")]
-    NOTE_CIRCULAR_TAP_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_RED")]
-    NOTE_CIRCULAR_TAP_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_GREEN")]
-    NOTE_CIRCULAR_TAP_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_BLUE")]
-    NOTE_CIRCULAR_TAP_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_YELLOW")]
-    NOTE_CIRCULAR_TAP_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_PURPLE")]
-    NOTE_CIRCULAR_TAP_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_CYAN")]
-    NOTE_CIRCULAR_ALTERNATIVE_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_NEUTRAL")]
-    NOTE_CIRCULAR_ALTERNATIVE_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_RED")]
-    NOTE_CIRCULAR_ALTERNATIVE_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_GREEN")]
-    NOTE_CIRCULAR_ALTERNATIVE_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_BLUE")]
-    NOTE_CIRCULAR_ALTERNATIVE_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_YELLOW")]
-    NOTE_CIRCULAR_ALTERNATIVE_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_PURPLE")]
-    NOTE_CIRCULAR_ALTERNATIVE_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_CYAN")]
-    NOTE_CIRCULAR_HOLD_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_NEUTRAL")]
-    NOTE_CIRCULAR_HOLD_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_RED")]
-    NOTE_CIRCULAR_HOLD_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_GREEN")]
-    NOTE_CIRCULAR_HOLD_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_BLUE")]
-    NOTE_CIRCULAR_HOLD_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_YELLOW")]
-    NOTE_CIRCULAR_HOLD_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_PURPLE")]
-    NOTE_CIRCULAR_HOLD_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_CYAN")]
-    NOTE_LINEAR_TAP_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_TAP_NEUTRAL")]
-    NOTE_LINEAR_TAP_RED = Annotated[Particle, particle("#NOTE_LINEAR_TAP_RED")]
-    NOTE_LINEAR_TAP_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_TAP_GREEN")]
-    NOTE_LINEAR_TAP_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_TAP_BLUE")]
-    NOTE_LINEAR_TAP_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_TAP_YELLOW")]
-    NOTE_LINEAR_TAP_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_TAP_PURPLE")]
-    NOTE_LINEAR_TAP_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_TAP_CYAN")]
-    NOTE_LINEAR_ALTERNATIVE_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_NEUTRAL")]
-    NOTE_LINEAR_ALTERNATIVE_RED = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_RED")]
-    NOTE_LINEAR_ALTERNATIVE_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_GREEN")]
-    NOTE_LINEAR_ALTERNATIVE_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_BLUE")]
-    NOTE_LINEAR_ALTERNATIVE_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_YELLOW")]
-    NOTE_LINEAR_ALTERNATIVE_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_PURPLE")]
-    NOTE_LINEAR_ALTERNATIVE_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_CYAN")]
-    NOTE_LINEAR_HOLD_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_NEUTRAL")]
-    NOTE_LINEAR_HOLD_RED = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_RED")]
-    NOTE_LINEAR_HOLD_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_GREEN")]
-    NOTE_LINEAR_HOLD_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_BLUE")]
-    NOTE_LINEAR_HOLD_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_YELLOW")]
-    NOTE_LINEAR_HOLD_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_PURPLE")]
-    NOTE_LINEAR_HOLD_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_CYAN")]
-    LANE_CIRCULAR = Annotated[Particle, particle("#LANE_CIRCULAR")]
-    LANE_LINEAR = Annotated[Particle, particle("#LANE_LINEAR")]
-    SLOT_CIRCULAR = Annotated[Particle, particle("#SLOT_CIRCULAR")]
-    SLOT_LINEAR = Annotated[Particle, particle("#SLOT_LINEAR")]
-    JUDGE_LINE_CIRCULAR = Annotated[Particle, particle("#JUDGE_LINE_CIRCULAR")]
-    JUDGE_LINE_LINEAR = Annotated[Particle, particle("#JUDGE_LINE_LINEAR")]
-
-
-@particles
-class EmptyParticles:
-    pass
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Annotated, Any, NewType, dataclass_transform, get_origin
+
+from sonolus.backend.ops import Op
+from sonolus.script.graphics import QuadLike, flatten_quad
+from sonolus.script.internal.introspection import get_field_specifiers
+from sonolus.script.internal.native import native_function
+from sonolus.script.record import Record
+
+
+class Particle(Record):
+    id: int
+
+    def is_available(self) -> bool:
+        return _has_particle_effect(self.id)
+
+    def spawn(self, quad: QuadLike, duration: float, loop: bool = False) -> ParticleHandle:
+        return ParticleHandle(_spawn_particle_effect(self.id, *flatten_quad(quad), duration, loop))
+
+
+class ParticleHandle(Record):
+    id: int
+
+    def move(self, quad: QuadLike) -> None:
+        _move_particle_effect(self.id, *flatten_quad(quad))
+
+    def destroy(self) -> None:
+        _destroy_particle_effect(self.id)
+
+
+@native_function(Op.HasParticleEffect)
+def _has_particle_effect(particle_id: int) -> bool:
+    raise NotImplementedError
+
+
+@native_function(Op.SpawnParticleEffect)
+def _spawn_particle_effect(
+    particle_id: int,
+    x1: float,
+    y1: float,
+    x2: float,
+    y2: float,
+    x3: float,
+    y3: float,
+    x4: float,
+    y4: float,
+    duration: float,
+    loop: bool,
+) -> int:
+    raise NotImplementedError
+
+
+@native_function(Op.MoveParticleEffect)
+def _move_particle_effect(
+    handle: int, x1: float, y1: float, x2: float, y2: float, x3: float, y3: float, x4: float, y4: float
+) -> None:
+    raise NotImplementedError
+
+
+@native_function(Op.DestroyParticleEffect)
+def _destroy_particle_effect(handle: int) -> None:
+    raise NotImplementedError
+
+
+@dataclass
+class ParticleInfo:
+    name: str
+
+
+def particle(name: str) -> Any:
+    return ParticleInfo(name)
+
+
+type Particles = NewType("Particles", Any)
+
+
+@dataclass_transform()
+def particles[T](cls: type[T]) -> T | Particles:
+    if len(cls.__bases__) != 1:
+        raise ValueError("Particles 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 particles: {annotation}")
+        annotation_type = annotation.__args__[0]
+        annotation_values = annotation.__metadata__
+        if annotation_type is not Particle:
+            raise TypeError(f"Invalid annotation for particles: {annotation}, expected annotation of type Particle")
+        if len(annotation_values) != 1 or not isinstance(annotation_values[0], ParticleInfo):
+            raise TypeError(
+                f"Invalid annotation for particles: {annotation}, expected a single string annotation value"
+            )
+        particle_name = annotation_values[0].name
+        names.append(particle_name)
+        setattr(instance, name, Particle(i))
+    instance._particles_ = names
+    instance._is_comptime_value_ = True
+    return instance
+
+
+class StandardParticle:
+    NOTE_CIRCULAR_TAP_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_NEUTRAL")]
+    NOTE_CIRCULAR_TAP_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_RED")]
+    NOTE_CIRCULAR_TAP_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_GREEN")]
+    NOTE_CIRCULAR_TAP_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_BLUE")]
+    NOTE_CIRCULAR_TAP_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_YELLOW")]
+    NOTE_CIRCULAR_TAP_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_PURPLE")]
+    NOTE_CIRCULAR_TAP_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_TAP_CYAN")]
+    NOTE_CIRCULAR_ALTERNATIVE_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_NEUTRAL")]
+    NOTE_CIRCULAR_ALTERNATIVE_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_RED")]
+    NOTE_CIRCULAR_ALTERNATIVE_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_GREEN")]
+    NOTE_CIRCULAR_ALTERNATIVE_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_BLUE")]
+    NOTE_CIRCULAR_ALTERNATIVE_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_YELLOW")]
+    NOTE_CIRCULAR_ALTERNATIVE_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_PURPLE")]
+    NOTE_CIRCULAR_ALTERNATIVE_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_ALTERNATIVE_CYAN")]
+    NOTE_CIRCULAR_HOLD_NEUTRAL = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_NEUTRAL")]
+    NOTE_CIRCULAR_HOLD_RED = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_RED")]
+    NOTE_CIRCULAR_HOLD_GREEN = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_GREEN")]
+    NOTE_CIRCULAR_HOLD_BLUE = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_BLUE")]
+    NOTE_CIRCULAR_HOLD_YELLOW = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_YELLOW")]
+    NOTE_CIRCULAR_HOLD_PURPLE = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_PURPLE")]
+    NOTE_CIRCULAR_HOLD_CYAN = Annotated[Particle, particle("#NOTE_CIRCULAR_HOLD_CYAN")]
+    NOTE_LINEAR_TAP_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_TAP_NEUTRAL")]
+    NOTE_LINEAR_TAP_RED = Annotated[Particle, particle("#NOTE_LINEAR_TAP_RED")]
+    NOTE_LINEAR_TAP_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_TAP_GREEN")]
+    NOTE_LINEAR_TAP_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_TAP_BLUE")]
+    NOTE_LINEAR_TAP_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_TAP_YELLOW")]
+    NOTE_LINEAR_TAP_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_TAP_PURPLE")]
+    NOTE_LINEAR_TAP_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_TAP_CYAN")]
+    NOTE_LINEAR_ALTERNATIVE_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_NEUTRAL")]
+    NOTE_LINEAR_ALTERNATIVE_RED = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_RED")]
+    NOTE_LINEAR_ALTERNATIVE_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_GREEN")]
+    NOTE_LINEAR_ALTERNATIVE_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_BLUE")]
+    NOTE_LINEAR_ALTERNATIVE_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_YELLOW")]
+    NOTE_LINEAR_ALTERNATIVE_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_PURPLE")]
+    NOTE_LINEAR_ALTERNATIVE_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_ALTERNATIVE_CYAN")]
+    NOTE_LINEAR_HOLD_NEUTRAL = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_NEUTRAL")]
+    NOTE_LINEAR_HOLD_RED = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_RED")]
+    NOTE_LINEAR_HOLD_GREEN = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_GREEN")]
+    NOTE_LINEAR_HOLD_BLUE = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_BLUE")]
+    NOTE_LINEAR_HOLD_YELLOW = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_YELLOW")]
+    NOTE_LINEAR_HOLD_PURPLE = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_PURPLE")]
+    NOTE_LINEAR_HOLD_CYAN = Annotated[Particle, particle("#NOTE_LINEAR_HOLD_CYAN")]
+    LANE_CIRCULAR = Annotated[Particle, particle("#LANE_CIRCULAR")]
+    LANE_LINEAR = Annotated[Particle, particle("#LANE_LINEAR")]
+    SLOT_CIRCULAR = Annotated[Particle, particle("#SLOT_CIRCULAR")]
+    SLOT_LINEAR = Annotated[Particle, particle("#SLOT_LINEAR")]
+    JUDGE_LINE_CIRCULAR = Annotated[Particle, particle("#JUDGE_LINE_CIRCULAR")]
+    JUDGE_LINE_LINEAR = Annotated[Particle, particle("#JUDGE_LINE_LINEAR")]
+
+
+@particles
+class EmptyParticles:
+    pass

sonolus/script/pointer.py

@@ -1,30 +1,30 @@
-from sonolus.backend.place import BlockPlace
-from sonolus.script.internal.impl import meta_fn, validate_value
-from sonolus.script.internal.value import Value
-from sonolus.script.num import Num, is_num
-
-
-@meta_fn
-def deref[T: Value](block: Num, offset: Num, type_: type[T]) -> T:
-    block = Num._accept_(block)
-    offset = Num._accept_(offset)
-    type_ = validate_value(type_)._as_py_()
-    if block._is_py_():
-        block = block._as_py_()
-        if not isinstance(block, int):
-            raise TypeError("block must be an integer")
-    else:
-        if not is_num(block):
-            raise TypeError("block must be a Num")
-        block = block.index()
-    if offset._is_py_():
-        offset = offset._as_py_()
-        if not isinstance(offset, int):
-            raise TypeError("offset must be an integer")
-    else:
-        if not is_num(offset):
-            raise TypeError("offset must be a Num")
-        offset = offset.index()
-    if not (isinstance(type_, type) and issubclass(type_, Value)):
-        raise TypeError("type_ must be a Value")
-    return type_._from_place_(BlockPlace(block, offset))
+from sonolus.backend.place import BlockPlace
+from sonolus.script.internal.impl import meta_fn, validate_value
+from sonolus.script.internal.value import Value
+from sonolus.script.num import Num, is_num
+
+
+@meta_fn
+def deref[T: Value](block: Num, offset: Num, type_: type[T]) -> T:
+    block = Num._accept_(block)
+    offset = Num._accept_(offset)
+    type_ = validate_value(type_)._as_py_()
+    if block._is_py_():
+        block = block._as_py_()
+        if not isinstance(block, int):
+            raise TypeError("block must be an integer")
+    else:
+        if not is_num(block):
+            raise TypeError("block must be a Num")
+        block = block.index()
+    if offset._is_py_():
+        offset = offset._as_py_()
+        if not isinstance(offset, int):
+            raise TypeError("offset must be an integer")
+    else:
+        if not is_num(offset):
+            raise TypeError("offset must be a Num")
+        offset = offset.index()
+    if not (isinstance(type_, type) and issubclass(type_, Value)):
+        raise TypeError("type_ must be a Value")
+    return type_._from_place_(BlockPlace(block, offset))

sonolus/script/print.py

@@ -1,81 +1,81 @@
-from enum import IntEnum
-
-from sonolus.backend.ops import Op
-from sonolus.script.internal.native import native_function
-from sonolus.script.runtime import HorizontalAlign
-from sonolus.script.vec import Vec2
-
-
-class PrintFormat(IntEnum):
-    NUMBER = 0
-    PERCENTAGE = 1
-    TIME = 10
-    SCORE = 11
-    BPM = 20
-    TIMESCALE = 21
-    BEAT_COUNT = 30
-    MEASURE_COUNT = 31
-    ENTITY_COUNT = 32
-
-
-class PrintColor(IntEnum):
-    THEME = -1
-    NEUTRAL = 0
-    RED = 1
-    GREEN = 2
-    BLUE = 3
-    YELLOW = 4
-    PURPLE = 5
-    CYAN = 6
-
-
-@native_function(Op.Print)
-def _print(
-    value: int | float,
-    format: PrintFormat,  # noqa: A002
-    decimal_places: int,
-    anchor_x: float,
-    anchor_y: float,
-    pivot_x: float,
-    pivot_y: float,
-    width: float,
-    height: float,
-    rotation: float,
-    color: PrintColor,
-    alpha: float,
-    horizontal_align: HorizontalAlign,
-    background: bool,
-):
-    raise NotImplementedError
-
-
-def print_number(
-    value: int | float,
-    *,
-    fmt: PrintFormat,
-    decimal_places: int = 0,
-    anchor: Vec2,
-    pivot: Vec2,
-    dimensions: Vec2,
-    rotation: float = 0,
-    color: PrintColor = PrintColor.THEME,
-    alpha: float = 1,
-    horizontal_align: HorizontalAlign = HorizontalAlign.LEFT,
-    background: bool = False,
-):
-    _print(
-        value,
-        fmt,
-        decimal_places,
-        anchor.x,
-        anchor.y,
-        pivot.x,
-        pivot.y,
-        dimensions.x,
-        dimensions.y,
-        rotation,
-        color,
-        alpha,
-        horizontal_align,
-        background,
-    )
+from enum import IntEnum
+
+from sonolus.backend.ops import Op
+from sonolus.script.internal.native import native_function
+from sonolus.script.runtime import HorizontalAlign
+from sonolus.script.vec import Vec2
+
+
+class PrintFormat(IntEnum):
+    NUMBER = 0
+    PERCENTAGE = 1
+    TIME = 10
+    SCORE = 11
+    BPM = 20
+    TIMESCALE = 21
+    BEAT_COUNT = 30
+    MEASURE_COUNT = 31
+    ENTITY_COUNT = 32
+
+
+class PrintColor(IntEnum):
+    THEME = -1
+    NEUTRAL = 0
+    RED = 1
+    GREEN = 2
+    BLUE = 3
+    YELLOW = 4
+    PURPLE = 5
+    CYAN = 6
+
+
+@native_function(Op.Print)
+def _print(
+    value: int | float,
+    format: PrintFormat,  # noqa: A002
+    decimal_places: int,
+    anchor_x: float,
+    anchor_y: float,
+    pivot_x: float,
+    pivot_y: float,
+    width: float,
+    height: float,
+    rotation: float,
+    color: PrintColor,
+    alpha: float,
+    horizontal_align: HorizontalAlign,
+    background: bool,
+):
+    raise NotImplementedError
+
+
+def print_number(
+    value: int | float,
+    *,
+    fmt: PrintFormat,
+    decimal_places: int = 0,
+    anchor: Vec2,
+    pivot: Vec2,
+    dimensions: Vec2,
+    rotation: float = 0,
+    color: PrintColor = PrintColor.THEME,
+    alpha: float = 1,
+    horizontal_align: HorizontalAlign = HorizontalAlign.LEFT,
+    background: bool = False,
+):
+    _print(
+        value,
+        fmt,
+        decimal_places,
+        anchor.x,
+        anchor.y,
+        pivot.x,
+        pivot.y,
+        dimensions.x,
+        dimensions.y,
+        rotation,
+        color,
+        alpha,
+        horizontal_align,
+        background,
+    )

sonolus/script/random.py

@@ -0,0 +1,14 @@
+import random as _random
+
+from sonolus.backend.ops import Op
+from sonolus.script.internal.native import native_function
+
+
+@native_function(Op.Random)
+def random_float(lo: float = 0.0, hi: float = 1.0, /) -> float:
+    return lo + (hi - lo) * _random.random()
+
+
+@native_function(Op.RandomInteger)
+def random_integer(lo: int, hi: int, /) -> int:
+    return _random.randint(lo, hi)