sonolus.py 0.1.2__tar.gz → 0.1.3__tar.gz

{sonolus_py-0.1.2 → sonolus_py-0.1.3}/PKG-INFO

@@ -1,8 +1,7 @@
 Metadata-Version: 2.3
 Name: sonolus.py
-Version: 0.1.2
+Version: 0.1.3
 Summary: Sonolus engine development in Python
-License-File: LICENSE
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 

{sonolus_py-0.1.2 → sonolus_py-0.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.1.2"
+version = "0.1.3"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.13"

{sonolus_py-0.1.2 → sonolus_py-0.1.3}/sonolus/backend/visitor.py

@@ -622,6 +622,8 @@ class Visitor(ast.NodeVisitor):
 
     def visit_Call(self, node):
         fn = self.visit(node.func)
+        if fn is Num:
+            raise ValueError("Calling int/bool/float is not supported")
         args = []
         kwargs = {}
         for arg in node.args:

{sonolus_py-0.1.2 → sonolus_py-0.1.3}/sonolus/build/engine.py

@@ -7,12 +7,15 @@ from pathlib import Path
 
 from sonolus.backend.mode import Mode
 from sonolus.build.compile import compile_mode
-from sonolus.build.defaults import EMPTY_ENGINE_TUTORIAL_DATA
 from sonolus.script.archetype import BaseArchetype
 from sonolus.script.bucket import Buckets
-from sonolus.script.callbacks import update_spawn_callback
+from sonolus.script.callbacks import navigate_callback, preprocess_callback, update_callback, update_spawn_callback
 from sonolus.script.effect import Effects
 from sonolus.script.engine import EngineData
+from sonolus.script.instruction import (
+    TutorialInstructionIcons,
+    TutorialInstructions,
+)
 from sonolus.script.internal.context import ReadOnlyMemory
 from sonolus.script.options import Options
 from sonolus.script.particle import Particles
@@ -61,17 +64,28 @@ def package_engine(engine: EngineData):
         rom=rom,
         update_spawn=engine.watch.update_spawn,
     )
-    preview_mode = build_preview_mode(
+    preview_data = build_preview_mode(
         archetypes=engine.preview.archetypes,
         skin=engine.preview.skin,
         rom=rom,
     )
+    tutorial_data = build_tutorial_mode(
+        skin=engine.tutorial.skin,
+        effects=engine.tutorial.effects,
+        particles=engine.tutorial.particles,
+        instructions=engine.tutorial.instructions,
+        instruction_icons=engine.tutorial.instruction_icons,
+        preprocess=engine.tutorial.preprocess,
+        navigate=engine.tutorial.navigate,
+        update=engine.tutorial.update,
+        rom=rom,
+    )
     return PackagedEngine(
         configuration=package_output(configuration),
         play_data=package_output(play_data),
         watch_data=package_output(watch_data),
-        preview_data=package_output(preview_mode),
-        tutorial_data=package_output(EMPTY_ENGINE_TUTORIAL_DATA),
+        preview_data=package_output(preview_data),
+        tutorial_data=package_output(tutorial_data),
         rom=package_rom(rom),
     )
 
@@ -134,6 +148,35 @@ def build_preview_mode(
     }
 
 
+def build_tutorial_mode(
+    skin: Skin,
+    effects: Effects,
+    particles: Particles,
+    instructions: TutorialInstructions,
+    instruction_icons: TutorialInstructionIcons,
+    preprocess: Callable[[], None],
+    navigate: Callable[[int], None],
+    update: Callable[[], None],
+    rom: ReadOnlyMemory,
+):
+    return {
+        **compile_mode(
+            mode=Mode.TUTORIAL,
+            rom=rom,
+            archetypes=[],
+            global_callbacks=[
+                (preprocess_callback, preprocess),
+                (navigate_callback, navigate),
+                (update_callback, update),
+            ],
+        ),
+        "skin": build_skin(skin),
+        "effect": build_effects(effects),
+        "particle": build_particles(particles),
+        "instruction": build_instructions(instructions, instruction_icons),
+    }
+
+
 def build_skin(skin: Skin) -> JsonValue:
     return {"sprites": [{"name": name, "id": i} for i, name in enumerate(skin._sprites_)]}
 
@@ -150,6 +193,13 @@ def build_buckets(buckets: Buckets) -> JsonValue:
     return [bucket.to_dict() for bucket in buckets._buckets_]
 
 
+def build_instructions(instructions: TutorialInstructions, instruction_icons: TutorialInstructionIcons) -> JsonValue:
+    return {
+        "texts": [{"name": name, "id": i} for i, name in enumerate(instructions._instructions_)],
+        "icons": [{"name": name, "id": i} for i, name in enumerate(instruction_icons._instruction_icons_)],
+    }
+
+
 def package_rom(rom: ReadOnlyMemory) -> bytes:
     values = rom.values or [0]
     output = bytearray()

{sonolus_py-0.1.2 → sonolus_py-0.1.3}/sonolus/script/callbacks.py

@@ -81,6 +81,18 @@ render_callback = CallbackInfo(
     supports_order=False,
     returns_value=False,
 )
+navigate_callback = CallbackInfo(
+    name="navigate",
+    py_name="navigate",
+    supports_order=False,
+    returns_value=False,
+)
+update_callback = CallbackInfo(
+    name="update",
+    py_name="update",
+    supports_order=False,
+    returns_value=False,
+)
 
 
 def _by_name(*callbacks: CallbackInfo) -> dict[str, CallbackInfo]:

{sonolus_py-0.1.2 → sonolus_py-0.1.3}/sonolus/script/engine.py

@@ -1,11 +1,18 @@
 from __future__ import annotations
 
 from collections.abc import Callable
+from typing import Any
 
 from sonolus.build.collection import Asset
 from sonolus.script.archetype import BaseArchetype, PlayArchetype, PreviewArchetype, WatchArchetype
 from sonolus.script.bucket import Buckets, EmptyBuckets
 from sonolus.script.effect import Effects, EmptyEffects
+from sonolus.script.instruction import (
+    EmptyInstructionIcons,
+    EmptyInstructions,
+    TutorialInstructionIcons,
+    TutorialInstructions,
+)
 from sonolus.script.options import EmptyOptions, Options
 from sonolus.script.particle import EmptyParticles, Particles
 from sonolus.script.sprite import EmptySkin, Skin
@@ -41,7 +48,7 @@ class Engine:
         self.data = data
 
 
-def default_callback() -> float:
+def default_callback() -> Any:
     return 0.0
 
 
@@ -104,6 +111,29 @@ class PreviewMode:
                 raise ValueError(f"archetype {archetype} is not a BaseArchetype")
 
 
+class TutorialMode:
+    def __init__(
+        self,
+        *,
+        skin: Skin = EmptySkin,
+        effects: Effects = EmptyEffects,
+        particles: Particles = EmptyParticles,
+        instructions: TutorialInstructions = EmptyInstructions,
+        instruction_icons: TutorialInstructionIcons = EmptyInstructionIcons,
+        preprocess: Callable[[], None],
+        navigate: Callable[[], None],
+        update: Callable[[], None],
+    ) -> None:
+        self.skin = skin
+        self.effects = effects
+        self.particles = particles
+        self.instructions = instructions
+        self.instruction_icons = instruction_icons
+        self.preprocess = preprocess
+        self.navigate = navigate
+        self.update = update
+
+
 class EngineData:
     def __init__(
         self,
@@ -113,9 +143,15 @@ class EngineData:
         play: PlayMode | None = None,
         watch: WatchMode | None = None,
         preview: PreviewMode | None = None,
+        tutorial: TutorialMode | None = None,
     ) -> None:
         self.ui = ui or UiConfig()
         self.options = options
         self.play = play or PlayMode()
         self.watch = watch or WatchMode(update_spawn=default_callback)
         self.preview = preview or PreviewMode()
+        self.tutorial = tutorial or TutorialMode(
+            preprocess=default_callback,
+            navigate=default_callback,
+            update=default_callback,
+        )

sonolus_py-0.1.3/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_py-0.1.2 → sonolus_py-0.1.3}/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_py-0.1.2 → sonolus_py-0.1.3}/sonolus/script/runtime.py

@@ -18,6 +18,7 @@ from sonolus.script.globals import (
     _runtime_particle_transform,
     _runtime_skin_transform,
     _runtime_touch_array,
+    _tutorial_instruction,
     _tutorial_runtime_environment,
     _tutorial_runtime_ui,
     _tutorial_runtime_ui_configuration,
@@ -181,6 +182,37 @@ class RuntimeUiLayout(Record):
             self.background = background
 
 
+class BasicRuntimeUiLayout(Record):
+    anchor: Vec2
+    pivot: Vec2
+    dimensions: Vec2
+    rotation: float
+    alpha: float
+    background: bool
+
+    def update(
+        self,
+        anchor: Vec2 | None = None,
+        pivot: Vec2 | None = None,
+        dimensions: Vec2 | None = None,
+        rotation: float | None = None,
+        alpha: float | None = None,
+        background: bool | None = None,
+    ):
+        if anchor is not None:
+            self.anchor = anchor
+        if pivot is not None:
+            self.pivot = pivot
+        if dimensions is not None:
+            self.dimensions = dimensions
+        if rotation is not None:
+            self.rotation = rotation
+        if alpha is not None:
+            self.alpha = alpha
+        if background is not None:
+            self.background = background
+
+
 @_play_runtime_ui
 class _PlayRuntimeUi:
     menu: RuntimeUiLayout
@@ -208,16 +240,16 @@ class _WatchRuntimeUi:
 
 @_preview_runtime_ui
 class _PreviewRuntimeUi:
-    menu: RuntimeUiLayout
-    progress: RuntimeUiLayout
+    menu: BasicRuntimeUiLayout
+    progress: BasicRuntimeUiLayout
 
 
 @_tutorial_runtime_ui
 class _TutorialRuntimeUi:
-    menu: RuntimeUiLayout
-    previous: RuntimeUiLayout
-    next: RuntimeUiLayout
-    instruction: RuntimeUiLayout
+    menu: BasicRuntimeUiLayout
+    previous: BasicRuntimeUiLayout
+    next: BasicRuntimeUiLayout
+    instruction: BasicRuntimeUiLayout
 
 
 class Touch(Record):
@@ -392,6 +424,11 @@ class _LevelLife:
             self.consecutive_good_step = consecutive_good_step
 
 
+@_tutorial_instruction
+class _TutorialInstruction:
+    text_id: int
+
+
 @meta_fn
 def is_debug() -> bool:
     if not ctx():

{sonolus_py-0.1.2 → sonolus_py-0.1.3}/sonolus/script/vec.py

@@ -1,6 +1,6 @@
 from typing import Self
 
-from sonolus.script.math import atan2
+from sonolus.script.math import atan2, cos, sin
 from sonolus.script.num import Num
 from sonolus.script.record import Record
 
@@ -44,6 +44,12 @@ class Vec2(Record):
     def dot(self, other: Self) -> Num:
         return self.x * other.x + self.y * other.y
 
+    def rotate(self, angle: Num) -> Self:
+        return Vec2(
+            x=self.x * cos(angle) - self.y * sin(angle),
+            y=self.x * sin(angle) + self.y * cos(angle),
+        )
+
     @property
     def tuple(self) -> tuple[float, float]:
         return self.x, self.y

sonolus_py-0.1.2/sonolus/build/defaults.py

@@ -1,32 +0,0 @@
-EMPTY_ENGINE_PLAY_DATA = {
-    "skin": {"sprites": []},
-    "effect": {"clips": []},
-    "particle": {"effects": []},
-    "buckets": [],
-    "archetypes": [],
-    "nodes": [{"value": 0}],
-}
-
-EMPTY_ENGINE_WATCH_DATA = {
-    "skin": {"sprites": []},
-    "effect": {"clips": []},
-    "particle": {"effects": []},
-    "buckets": [],
-    "archetypes": [],
-    "updateSpawn": 0,
-    "nodes": [{"value": 0}],
-}
-
-EMPTY_ENGINE_PREVIEW_DATA = {
-    "skin": {"sprites": []},
-    "archetypes": [],
-    "nodes": [{"value": 0}],
-}
-
-EMPTY_ENGINE_TUTORIAL_DATA = {
-    "skin": {"sprites": []},
-    "effect": {"clips": []},
-    "particle": {"effects": []},
-    "instruction": {"texts": [], "icons": []},
-    "nodes": [{"value": 0}],
-}

sonolus_py-0.1.2/sonolus/script/icon.py

@@ -1,73 +0,0 @@
-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"