sonolus.py 0.6.3__tar.gz → 0.6.5__tar.gz

{sonolus_py-0.6.3 → sonolus_py-0.6.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.6.3
+Version: 0.6.5
 Summary: Sonolus engine development in Python
 License-File: LICENSE
 Requires-Python: >=3.12

{sonolus_py-0.6.3 → sonolus_py-0.6.5}/pyproject.toml

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

{sonolus_py-0.6.3 → sonolus_py-0.6.5}/sonolus/script/archetype.py

@@ -1,4 +1,3 @@
-# type: ignore
 from __future__ import annotations
 
 import inspect
@@ -120,7 +119,7 @@ class _ArchetypeField(SonolusDescriptor):
         if ctx():
             return result._get_readonly_()
         else:
-            return result._as_py_()
+            return result._as_py_()  # type: ignore
 
     def __set__(self, instance: _BaseArchetype, value):
         if instance is None:
@@ -207,7 +206,7 @@ class _IsScoredDescriptor(SonolusDescriptor):
         if instance is None:
             return self.value
         elif ctx():
-            raise RuntimeError("Cannot access is_scored from self in a callback, use ArchetypeClass.is_scored")
+            return ctx().global_state.is_scored_by_archetype_id[instance.id]
         else:
             return self.value
 
@@ -237,7 +236,7 @@ class _KeyDescriptor(SonolusDescriptor):
 
     def __get__(self, instance, owner):
         if instance is not None and ctx():
-            return ctx().global_state.keys[instance.id]
+            return ctx().global_state.keys_by_archetype_id[instance.id]
         else:
             return self.value
 
@@ -362,37 +361,6 @@ _annotation_defaults: dict[Callable, _ArchetypeFieldInfo] = {
 }
 
 
-class StandardImport:
-    """Standard import annotations for Archetype fields.
-
-    Usage:
-        ```python
-        class MyArchetype(WatchArchetype):
-            judgment: StandardImport.JUDGMENT
-        ```
-    """
-
-    BEAT = Annotated[float, imported(name="#BEAT")]
-    """The beat of the entity."""
-
-    BPM = Annotated[float, imported(name="#BPM")]
-    """The bpm, for bpm change markers."""
-
-    TIMESCALE = Annotated[float, imported(name="#TIMESCALE")]
-    """The timescale, for timescale change markers."""
-
-    JUDGMENT = Annotated[int, imported(name="#JUDGMENT")]
-    """The judgment of the entity.
-
-    Automatically supported in watch mode for archetypes with a corresponding scored play mode archetype.
-    """
-    ACCURACY = Annotated[float, imported(name="#ACCURACY")]
-    """The accuracy of the entity.
-
-    Automatically supported in watch mode for archetypes with a corresponding scored play mode archetype.
-    """
-
-
 def callback[T: Callable](*, order: int = 0) -> Callable[[T], T]:
     """Annotate a callback with its order.
 
@@ -604,6 +572,7 @@ class _BaseArchetype:
         cls._key_ = cls.key
         cls.key = _KeyDescriptor(cls.key)
         cls.name = _NameDescriptor(cls.name)
+        cls._is_scored_ = cls.is_scored
         cls.is_scored = _IsScoredDescriptor(cls.is_scored)
         cls.life = _ArchetypeLifeDescriptor()
 
@@ -624,6 +593,7 @@ class _BaseArchetype:
                 "life",
                 "is_scored",
                 "_key_",
+                "_is_scored_",
                 "_derived_base_",
                 "_is_derived_",
                 "_default_callbacks_",
@@ -842,12 +812,14 @@ class PlayArchetype(_BaseArchetype):
 
         Runs when the level is loaded after [`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess].
         """
+        return 0.0
 
     def should_spawn(self) -> bool:
         """Return whether the entity should be spawned.
 
         Runs each frame while the entity is the first entity in the spawn queue.
         """
+        return True
 
     def initialize(self):
         """Initialize this entity.
@@ -995,9 +967,11 @@ class WatchArchetype(_BaseArchetype):
 
     def spawn_time(self) -> float:
         """Return the spawn time of the entity."""
+        return 0.0
 
     def despawn_time(self) -> float:
         """Return the despawn time of the entity."""
+        return 0.0
 
     def initialize(self):
         """Initialize this entity.
@@ -1134,16 +1108,16 @@ def get_archetype_by_name(name: str) -> AnyArchetype:
     """Return the archetype with the given name in the current mode."""
     if not ctx():
         raise RuntimeError("Archetypes by name are only available during compilation.")
-    name = validate_value(name)
-    if not name._is_py_():
+    name = validate_value(name)  # type: ignore
+    if not name._is_py_():  # type: ignore
         raise TypeError(f"Invalid name: '{name}'")
-    name = name._as_py_()
+    name = name._as_py_()  # type: ignore
     if not isinstance(name, str):
         raise TypeError(f"Invalid name: '{name}'")
     archetypes_by_name = ctx().global_state.archetypes_by_name
     if name not in archetypes_by_name:
         raise KeyError(f"Unknown archetype: '{name}'")
-    return archetypes_by_name[name]
+    return archetypes_by_name[name]  # type: ignore
 
 
 @meta_fn
@@ -1313,6 +1287,84 @@ class StandardArchetypeName(StrEnum):
     TIMESCALE_CHANGE = "#TIMESCALE_CHANGE"
     """Timescale change marker"""
 
+    TIMESCALE_GROUP = "#TIMESCALE_GROUP"
+    """Entity referenced by the timescale changes in a group"""
+
 
 type AnyArchetype = PlayArchetype | WatchArchetype | PreviewArchetype
 """Union of all archetype types."""
+
+
+class StandardImportName:
+    """Standard import names for Archetype fields.
+
+    Usage:
+        ```python
+        class MyArchetype(WatchArchetype):
+            judgment: int = imported(name=StandardImportName.JUDGMENT)
+        ```
+    """
+
+    BEAT = "#BEAT"
+    """The beat of the entity."""
+
+    BPM = "#BPM"
+    """The bpm, for bpm change markers."""
+
+    TIMESCALE = "#TIMESCALE"
+    """The timescale, for timescale change markers."""
+
+    TIMESCALE_SKIP = "#TIMESCALE_SKIP"
+    """The scaled time to skip, for timescale change markers."""
+
+    TIMESCALE_GROUP = "#TIMESCALE_GROUP"
+    """The timescale group, for timescale change markers."""
+
+    JUDGMENT = "#JUDGMENT"
+    """The judgment of the entity.
+
+    Automatically set in watch mode for archetypes with a corresponding scored play mode archetype.
+    """
+
+    ACCURACY = "#ACCURACY"
+    """The accuracy of the entity.
+
+    Automatically set in watch mode for archetypes with a corresponding scored play mode archetype.
+    """
+
+
+class StandardImport:
+    """Standard import annotations for Archetype fields.
+
+    Usage:
+        ```python
+        class MyArchetype(WatchArchetype):
+            judgment: StandardImport.JUDGMENT
+        ```
+    """
+
+    BEAT = Annotated[float, imported(name=StandardImportName.BEAT)]
+    """The beat of the entity."""
+
+    BPM = Annotated[float, imported(name=StandardImportName.BPM)]
+    """The bpm, for bpm change markers."""
+
+    TIMESCALE = Annotated[float, imported(name=StandardImportName.TIMESCALE)]
+    """The timescale, for timescale change markers."""
+
+    TIMESCALE_SKIP = Annotated[float, imported(name=StandardImportName.TIMESCALE_SKIP)]
+    """The scaled time to skip, for timescale change markers."""
+
+    TIMESCALE_GROUP = Annotated[EntityRef[Any], imported(name=StandardImportName.TIMESCALE_GROUP)]
+    """The timescale group, for timescale change markers."""
+
+    JUDGMENT = Annotated[int, imported(name=StandardImportName.JUDGMENT)]
+    """The judgment of the entity.
+
+    Automatically set in watch mode for archetypes with a corresponding scored play mode archetype.
+    """
+    ACCURACY = Annotated[float, imported(name=StandardImportName.ACCURACY)]
+    """The accuracy of the entity.
+
+    Automatically set in watch mode for archetypes with a corresponding scored play mode archetype.
+    """

{sonolus_py-0.6.3 → sonolus_py-0.6.5}/sonolus/script/easing.py

@@ -355,8 +355,8 @@ def smootherstep(x: float) -> float:
 
 
 def step_start(x: float) -> float:
-    """Step function returning 1.0 if x > 0, otherwise 0.0."""
-    return 1.0 if x > 0 else 0.0
+    """Step function returning 1.0 if x >= 0, otherwise 0.0."""
+    return 1.0 if x >= 0 else 0.0
 
 
 def step_end(x: float) -> float:

{sonolus_py-0.6.3 → sonolus_py-0.6.5}/sonolus/script/internal/context.py

@@ -42,7 +42,8 @@ debug_var = ContextVar("debug_var", default=_disabled_debug_config)
 class GlobalContextState:
     archetypes: dict[type, int]
     archetypes_by_name: dict[str, type]
-    keys: Sequence[int] | None
+    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]
@@ -55,10 +56,14 @@ class GlobalContextState:
 
         self.archetypes = archetypes or {}
         self.archetypes_by_name = {type_.name: type_ for type_, _ in self.archetypes.items()}  # type: ignore
-        self.keys = (
-            Array(*((getattr(a, "_key_", -1)) for a in sorted(self.archetypes, key=lambda a: archetypes[a])))
+        ordered_archetypes = sorted(self.archetypes, key=lambda a: self.archetypes[a])
+        self.keys_by_archetype_id = (
+            Array(*((getattr(a, "_key_", -1)) for a in ordered_archetypes)) if archetypes else Array[int, Literal[0]]()
+        )
+        self.is_scored_by_archetype_id = (
+            Array(*((getattr(a, "_is_scored_", False)) for a in ordered_archetypes))
             if archetypes
-            else Array[int, Literal[0]]()
+            else Array[bool, Literal[0]]()
         )
         self.rom = ReadOnlyMemory() if rom is None else rom
         self.const_mappings = {}

{sonolus_py-0.6.3 → sonolus_py-0.6.5}/uv.lock

@@ -694,7 +694,7 @@ wheels = [
 
 [[package]]
 name = "sonolus-py"
-version = "0.6.3"
+version = "0.6.5"
 source = { editable = "." }
 
 [package.dev-dependencies]