sonolus.py 0.1.0__py3-none-any.whl

sonolus/script/globals.py

@@ -0,0 +1,234 @@
+import inspect
+from typing import dataclass_transform
+
+from sonolus.backend.blocks import Block, PlayBlock, PreviewBlock, TutorialBlock, WatchBlock
+from sonolus.backend.mode import Mode
+from sonolus.script.internal.descriptor import SonolusDescriptor
+from sonolus.script.internal.generic import validate_concrete_type
+from sonolus.script.internal.value import Value
+
+
+class GlobalInfo:
+    def __init__(self, name: str, size: int, blocks: dict[Mode, Block], offset: int | None):
+        self.name = name
+        self.size = size
+        self.blocks = blocks
+        self.offset = offset
+
+
+class GlobalField(SonolusDescriptor):
+    def __init__(self, name: str, type_: type[Value], index: int, offset: int):
+        self.name = name
+        self.type = type_
+        self.index = index
+        self.offset = offset
+
+    def __get__(self, instance, owner):
+        if instance is None:
+            return self
+
+        from sonolus.script.internal.context import ctx
+
+        info = owner._global_info_
+        if not ctx():
+            raise RuntimeError("Global field access outside of compilation")
+        base = ctx().get_global_base(info)
+        return self.type._from_place_(base.add_offset(self.offset))._get_()
+
+    def __set__(self, instance, value):
+        from sonolus.script.internal.context import ctx
+
+        info = instance._global_info_
+        if not ctx():
+            raise RuntimeError("Global field access outside of compilation")
+        base = ctx().get_global_base(info)
+        target = self.type._from_place_(base.add_offset(self.offset))
+        if self.type._is_value_type_():
+            target._set_(value)
+        else:
+            target._copy_from_(value)
+
+
+class GlobalPlaceholder:
+    def __init__(self, type_: type[Value], blocks: dict[Mode, Block], offset: int | None):
+        self.type = type_
+        self.blocks = blocks
+        self.offset = offset
+        self.size = type_._size_()
+
+    def get(self):
+        from sonolus.script.internal.context import ctx
+
+        if not ctx():
+            raise RuntimeError("Global access outside of compilation")
+        base = ctx().get_global_base(self)
+        return self.type._from_place_(base)
+
+
+def create_global(cls: type, blocks: dict[Mode, Block], offset: int | None):
+    if issubclass(cls, Value):
+        cls = validate_concrete_type(cls)
+        return GlobalPlaceholder(cls, blocks, offset)
+    if len(cls.__bases__) != 1:
+        raise TypeError("Expected a class with no bases or a Value subclass")
+    field_offset = 0
+    for i, (
+        name,
+        annotation,
+    ) in enumerate(inspect.get_annotations(cls, eval_str=True).items()):
+        type_ = validate_concrete_type(annotation)
+        setattr(cls, name, GlobalField(name, type_, i, field_offset))
+        field_offset += type_._size_()
+    cls._global_info_ = GlobalInfo(cls.__name__, field_offset, blocks, offset)
+    cls._is_comptime_value_ = True
+    return cls()
+
+
+@dataclass_transform()
+def _play_runtime_environment[T](cls: type[T]) -> T:
+    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)
+
+
+@dataclass_transform()
+def _tutorial_runtime_environment[T](cls: type[T]) -> T:
+    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)
+
+
+@dataclass_transform()
+def _play_runtime_update[T](cls: type[T]) -> T:
+    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)
+
+
+@dataclass_transform()
+def _tutorial_runtime_update[T](cls: type[T]) -> T:
+    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)
+
+
+@dataclass_transform()
+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,
+        },
+        0,
+    )
+
+
+@dataclass_transform()
+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,
+        },
+        0,
+    )
+
+
+@dataclass_transform()
+def _runtime_background[T](cls: type[T]) -> T:
+    return create_global(
+        cls,
+        {
+            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,
+    )
+
+
+@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,
+    )
+
+
+@dataclass_transform()
+def _tutorial_instruction[T](cls: type[T]) -> T:
+    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)
+
+
+@dataclass_transform()
+def level_data[T](cls: type[T]) -> T:
+    return create_global(cls, {Mode.Play: PlayBlock.LevelData, Mode.Watch: WatchBlock.LevelData}, None)
+
+
+# level_option is handled by the options decorator
+# level_bucket is handled by the bucket decorator
+
+
+@dataclass_transform()
+def _level_score[T](cls: type[T]) -> T:
+    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)
+
+
+# engine_rom is handled by the compiler
+# entity memory is handled by the archetype
+# entity data is handled by the archetype
+# entity shared memory is handled by the archetype
+# entity info is handled by the archetype
+# entity despawn is handled by the archetype
+# entity input is handled by the archetype
+# entity data array is handled by the archetype
+# entity shared memory array is handled by the archetype
+# entity info array is handled by the archetype
+# archetype life is handled by the archetype
+# temporary memory is handled by the compiler

sonolus/script/graphics.py

@@ -0,0 +1,141 @@
+from __future__ import annotations
+
+from typing import Protocol
+
+from sonolus.script.record import Record
+from sonolus.script.vec import Vec2
+
+
+class Quad(Record):
+    bl: Vec2
+    tl: Vec2
+    tr: Vec2
+    br: Vec2
+
+
+class Rect(Record):
+    t: float
+    r: float
+    b: float
+    l: float  # noqa: E741
+
+    @classmethod
+    def from_xywh(cls, x: float, y: float, w: float, h: float) -> 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,
+        )
+
+    @property
+    def x(self) -> float:
+        return self.l
+
+    @x.setter
+    def x(self, value: float):
+        self.r += value - self.l
+        self.l = value
+
+    @property
+    def y(self) -> float:
+        return self.t
+
+    @y.setter
+    def y(self, value: float):
+        self.b += value - self.t
+        self.t = value
+
+    @property
+    def w(self) -> float:
+        return self.r - self.l
+
+    @w.setter
+    def w(self, value: float):
+        self.r = self.l + value
+
+    @property
+    def h(self) -> float:
+        return self.t - self.b
+
+    @h.setter
+    def h(self, value: float):
+        self.t = self.b + value
+
+    @property
+    def bl(self) -> Vec2:
+        return Vec2(self.l, self.b)
+
+    @property
+    def tl(self) -> Vec2:
+        return Vec2(self.l, self.t)
+
+    @property
+    def tr(self) -> Vec2:
+        return Vec2(self.r, self.t)
+
+    @property
+    def br(self) -> Vec2:
+        return Vec2(self.r, self.b)
+
+    @property
+    def center(self) -> Vec2:
+        return Vec2((self.l + self.r) / 2, (self.t + self.b) / 2)
+
+    def as_quad(self) -> Quad:
+        return Quad(
+            bl=self.bl,
+            tl=self.tl,
+            tr=self.tr,
+            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
+
+
+class QuadLike(Protocol):
+    @property
+    def bl(self) -> Vec2: ...
+
+    @property
+    def tl(self) -> Vec2: ...
+
+    @property
+    def tr(self) -> Vec2: ...
+
+    @property
+    def br(self) -> Vec2: ...
+
+
+def flatten_quad(quad: QuadLike) -> tuple[float, float, float, float, float, float, float, float]:
+    return (
+        quad.bl.x,
+        quad.bl.y,
+        quad.tl.x,
+        quad.tl.y,
+        quad.tr.x,
+        quad.tr.y,
+        quad.br.x,
+        quad.br.y,
+    )

sonolus/script/icon.py

@@ -0,0 +1,73 @@
+from enum import StrEnum
+
+
+class StandardIcon(StrEnum):
+    ADVANCED = "advanced"
+    ANGLE_DOWN = "angleDown"
+    ANGLE_LEFT = "angleLeft"
+    ANGLE_RIGHT = "angleRight"
+    ANGLES_DOWN = "anglesDown"
+    ANGLES_LEFT = "anglesLeft"
+    ANGLES_RIGHT = "anglesRight"
+    ANGLES_UP = "anglesUp"
+    ANGLE_UP = "angleUp"
+    ARROW_DOWN = "arrowDown"
+    ARROW_LEFT = "arrowLeft"
+    ARROW_RIGHT = "arrowRight"
+    ARROW_UP = "arrowUp"
+    AWARD = "award"
+    BACKGROUND = "background"
+    BELL = "bell"
+    BELL_SLASH = "bellSlash"
+    BOOKMARK = "bookmark"
+    BOOKMARK_HOLLOW = "bookmarkHollow"
+    CHECK = "check"
+    CLOCK = "clock"
+    COMMENT = "comment"
+    CROWN = "crown"
+    DELETE = "delete"
+    EDIT = "edit"
+    EFFECT = "effect"
+    ENGINE = "engine"
+    ENVELOPE = "envelope"
+    ENVELOPE_OPEN = "envelopeOpen"
+    GLOBE = "globe"
+    HEART = "heart"
+    HEART_HOLLOW = "heartHollow"
+    HIDE = "hide"
+    INFORMATION = "information"
+    LEVEL = "level"
+    LOCK = "lock"
+    MEDAL = "medal"
+    MESSAGE = "message"
+    MINUS = "minus"
+    OPTIONS = "options"
+    PARTICLE = "particle"
+    PIN = "pin"
+    PLAYER = "player"
+    PLAYLIST = "playlist"
+    PLUS = "plus"
+    POST = "post"
+    QUESTION = "question"
+    RANKING = "ranking"
+    REPLAY = "replay"
+    REPLY = "reply"
+    RESTORE = "restore"
+    ROOM = "room"
+    SEARCH = "search"
+    SETTINGS = "settings"
+    SHOW = "show"
+    SHUFFLE = "shuffle"
+    SKIN = "skin"
+    STAR = "star"
+    STAR_HALF = "starHalf"
+    STAR_HOLLOW = "starHollow"
+    STOPWATCH = "stopwatch"
+    TAG = "tag"
+    THUMBS_DOWN = "thumbsDown"
+    THUMBS_DOWN_HOLLOW = "thumbsDownHollow"
+    THUMBS_UP = "thumbsUp"
+    THUMBS_UP_HOLLOW = "thumbsUpHollow"
+    TROPHY = "trophy"
+    UNLOCK = "unlock"
+    X_MARK = "xMark"

sonolus/script/internal/__init__.py

@@ -0,0 +1,5 @@
+"""Internal scripting details.
+
+These are internal details of scripting which typically should not be used directly
+in engine code.
+"""

sonolus/script/internal/builtin_impls.py

@@ -0,0 +1,144 @@
+from collections.abc import Iterable
+from typing import overload
+
+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.range import Range
+
+
+@meta_fn
+def _isinstance(value, type_):
+    value = validate_value(value)
+    type_ = validate_value(type_)._as_py_()
+    return validate_value(isinstance(value, type_))
+
+
+@meta_fn
+def _len(value):
+    from sonolus.backend.visitor import compile_and_call
+
+    value = validate_value(value)
+    if not hasattr(value, "__len__"):
+        raise TypeError(f"object of type '{type(value).__name__}' has no len()")
+    return compile_and_call(value.__len__)
+
+
+@meta_fn
+def _enumerate(iterable, start=0):
+    from sonolus.backend.visitor import compile_and_call
+
+    iterable = validate_value(iterable)
+    if not hasattr(iterable, "__iter__"):
+        raise TypeError(f"'{type(iterable).__name__}' object is not iterable")
+    if isinstance(iterable, ArrayLike):
+        return compile_and_call(iterable.enumerate, start)
+    else:
+        iterator = compile_and_call(iterable.__iter__)
+        if not isinstance(iterator, SonolusIterator):
+            raise TypeError("Only subclasses of SonolusIterator are supported as iterators")
+        return Enumerator(0, start, iterator)
+
+
+@meta_fn
+def _abs(value):
+    from sonolus.backend.visitor import compile_and_call
+
+    value = validate_value(value)
+    if not hasattr(value, "__abs__"):
+        raise TypeError(f"bad operand type for abs(): '{type(value).__name__}'")
+    return compile_and_call(value.__abs__)
+
+
+@overload
+def _max[T](iterable: Iterable[T]) -> T: ...
+
+
+@overload
+def _max[T](a: T, b: T, *args: T) -> T: ...
+
+
+@meta_fn
+def _max(*args):
+    from sonolus.backend.visitor import compile_and_call
+
+    args = tuple(validate_value(arg) for arg in args)
+    if len(args) == 0:
+        raise ValueError("Expected at least one argument to max")
+    elif len(args) == 1:
+        (iterable,) = args
+        if isinstance(iterable, ArrayLike):
+            return iterable.max()
+        else:
+            raise TypeError(f"Unsupported type: {type(iterable)} for max")
+    else:
+        if not all(isinstance(arg, Num) for arg in args):
+            raise TypeError("Arguments to max must be numbers")
+        if ctx():
+            result = compile_and_call(_max2, args[0], args[1])
+            for arg in args[2:]:
+                result = compile_and_call(_max2, result, arg)
+            return result
+        else:
+            return max(arg._as_py_() for arg in args)
+
+
+def _max2(a, b):
+    if a > b:
+        return a
+    else:
+        return b
+
+
+@overload
+def _min[T](iterable: Iterable[T]) -> T: ...
+
+
+@overload
+def _min[T](a: T, b: T, *args: T) -> T: ...
+
+
+@meta_fn
+def _min(*args):
+    from sonolus.backend.visitor import compile_and_call
+
+    args = tuple(validate_value(arg) for arg in args)
+    if len(args) == 0:
+        raise ValueError("Expected at least one argument to min")
+    elif len(args) == 1:
+        (iterable,) = args
+        if isinstance(iterable, ArrayLike):
+            return iterable.min()
+        else:
+            raise TypeError(f"Unsupported type: {type(iterable)} for min")
+    else:
+        if not all(isinstance(arg, Num) for arg in args):
+            raise TypeError("Arguments to min must be numbers")
+        if ctx():
+            result = compile_and_call(_min2, args[0], args[1])
+            for arg in args[2:]:
+                result = compile_and_call(_min2, result, arg)
+            return result
+        else:
+            return min(arg._as_py_() for arg in args)
+
+
+def _min2(a, b):
+    if a < b:
+        return a
+    else:
+        return b
+
+
+BUILTIN_IMPLS = {
+    id(isinstance): _isinstance,
+    id(len): _len,
+    id(enumerate): _enumerate,
+    id(abs): _abs,
+    id(max): _max,
+    id(min): _min,
+    id(range): Range,
+    **MATH_BUILTIN_IMPLS,
+}