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

sonolus/script/graphics.py

@@ -1,150 +1,200 @@
-from __future__ import annotations
-
-from typing import Protocol, Self
-
-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_center(cls, center: Vec2, dimensions: Vec2) -> Rect:
-        return cls(
-            t=center.y + dimensions.y / 2,
-            r=center.x + dimensions.x / 2,
-            b=center.y - dimensions.y / 2,
-            l=center.x - dimensions.x / 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, factor: Vec2, /) -> Self:
-        return Rect(
-            t=self.t * factor.y,
-            r=self.r * factor.x,
-            b=self.b * factor.y,
-            l=self.l * factor.x,
-        )
-
-    def expand(self, expansion: Vec2, /) -> Self:
-        return Rect(
-            t=self.t + expansion.y,
-            r=self.r + expansion.x,
-            b=self.b - expansion.y,
-            l=self.l - expansion.x,
-        )
-
-    def shrink(self, shrinkage: Vec2, /) -> Self:
-        return Rect(
-            t=self.t - shrinkage.y,
-            r=self.r - shrinkage.x,
-            b=self.b + shrinkage.y,
-            l=self.l + shrinkage.x,
-        )
-
-    def translate(self, translation: Vec2, /) -> Self:
-        return Rect(
-            t=self.t + translation.y,
-            r=self.r + translation.x,
-            b=self.b + translation.y,
-            l=self.l + translation.x,
-        )
-
-
-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,
-    )
+from __future__ import annotations
+
+from typing import Protocol, Self
+
+from sonolus.script.record import Record
+from sonolus.script.vec import Vec2
+
+
+class Quad(Record):
+    bl: Vec2
+    tl: Vec2
+    tr: Vec2
+    br: Vec2
+
+    @property
+    def center(self) -> Vec2:
+        return (self.bl + self.tr + self.tl + self.br) / 4
+
+    def translate(self, translation: Vec2, /) -> Self:
+        return Quad(
+            bl=self.bl + translation,
+            tl=self.tl + translation,
+            tr=self.tr + translation,
+            br=self.br + translation,
+        )
+
+    def scale(self, factor: Vec2, /) -> Self:
+        return Quad(
+            bl=self.bl * factor,
+            tl=self.tl * factor,
+            tr=self.tr * factor,
+            br=self.br * factor,
+        )
+
+    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Self:
+        return Quad(
+            bl=(self.bl - pivot) * factor + pivot,
+            tl=(self.tl - pivot) * factor + pivot,
+            tr=(self.tr - pivot) * factor + pivot,
+            br=(self.br - pivot) * factor + pivot,
+        )
+
+    def scale_centered(self, factor: Vec2, /) -> Self:
+        return Quad(
+            bl=self.bl * factor,
+            tl=self.tl * factor,
+            tr=self.tr * factor,
+            br=self.br * factor,
+        ).translate(self.center * (Vec2(1, 1) - factor))
+
+    def rotate(self, angle: float, /) -> Self:
+        return Quad(
+            bl=self.bl.rotate(angle),
+            tl=self.tl.rotate(angle),
+            tr=self.tr.rotate(angle),
+            br=self.br.rotate(angle),
+        )
+
+    def rotate_about(
+        self,
+        angle: float,
+        /,
+        pivot: Vec2,
+    ) -> Self:
+        return Quad(
+            bl=self.bl.rotate_about(angle, pivot),
+            tl=self.tl.rotate_about(angle, pivot),
+            tr=self.tr.rotate_about(angle, pivot),
+            br=self.br.rotate_about(angle, pivot),
+        )
+
+    def rotate_centered(self, angle: float, /) -> Self:
+        return self.rotate_about(angle, self.center)
+
+
+class Rect(Record):
+    t: float
+    r: float
+    b: float
+    l: float  # noqa: E741
+
+    @classmethod
+    def from_center(cls, center: Vec2, dimensions: Vec2) -> Rect:
+        return cls(
+            t=center.y + dimensions.y / 2,
+            r=center.x + dimensions.x / 2,
+            b=center.y - dimensions.y / 2,
+            l=center.x - dimensions.x / 2,
+        )
+
+    @property
+    def w(self) -> float:
+        return self.r - self.l
+
+    @property
+    def h(self) -> float:
+        return self.t - self.b
+
+    @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 translate(self, translation: Vec2, /) -> Self:
+        return Rect(
+            t=self.t + translation.y,
+            r=self.r + translation.x,
+            b=self.b + translation.y,
+            l=self.l + translation.x,
+        )
+
+    def scale(self, factor: Vec2, /) -> Self:
+        return Rect(
+            t=self.t * factor.y,
+            r=self.r * factor.x,
+            b=self.b * factor.y,
+            l=self.l * factor.x,
+        )
+
+    def scale_about(self, factor: Vec2, /, pivot: Vec2) -> Self:
+        return Rect(
+            t=(self.t - pivot.y) * factor.y + pivot.y,
+            r=(self.r - pivot.x) * factor.x + pivot.x,
+            b=(self.b - pivot.y) * factor.y + pivot.y,
+            l=(self.l - pivot.x) * factor.x + pivot.x,
+        )
+
+    def scale_centered(self, factor: Vec2, /) -> Self:
+        return Rect(
+            t=self.t * factor.y,
+            r=self.r * factor.x,
+            b=self.b * factor.y,
+            l=self.l * factor.x,
+        ).translate(self.center * (Vec2(1, 1) - factor))
+
+    def expand(self, expansion: Vec2, /) -> Self:
+        return Rect(
+            t=self.t + expansion.y,
+            r=self.r + expansion.x,
+            b=self.b - expansion.y,
+            l=self.l - expansion.x,
+        )
+
+    def shrink(self, shrinkage: Vec2, /) -> Self:
+        return Rect(
+            t=self.t - shrinkage.y,
+            r=self.r - shrinkage.x,
+            b=self.b + shrinkage.y,
+            l=self.l + shrinkage.x,
+        )
+
+
+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/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/script/internal/__init__.py

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